Fix merge conflicts

xplicit · xplicit · commit eccabd346e50 · 2017-05-23T19:05:54.000+07:00
diff --git a/src/ServiceStack.Text/Common/DeserializeTypeRefJson.cs b/src/ServiceStack.Text/Common/DeserializeTypeRefJson.cs
@@ -73,7 +73,7 @@ internal static object StringToType(
                 return null;
 
             //if (!Serializer.EatMapStartChar(strType, ref index))
-            for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (strType.GetChar(index++) != JsWriter.MapStartChar)
                 throw DeserializeTypeRef.CreateSerializationError(type, strType.Value);
 
@@ -91,7 +91,7 @@ internal static object StringToType(
                 var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);
 
                 //Serializer.EatMapKeySeperator(strType, ref index);
-                for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                 if (strType.Length != index) index++;
 
                 var propertyValueStr = Serializer.EatValue(strType, ref index);
@@ -165,13 +165,13 @@ internal static object StringToType(
                         }
 
                         //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
-                        for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                        for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                         if (index != strType.Length)
                         {
                             var success = strType.GetChar(index) == JsWriter.ItemSeperator || strType.GetChar(index) == JsWriter.MapEndChar;
                             index++;
                             if (success)
-                                for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                                for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                         }
 
                         continue;
@@ -208,13 +208,13 @@ internal static object StringToType(
                 }
 
                 //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
-                for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                 if (index != strType.Length)
                 {
                     var success = strType.GetChar(index) == JsWriter.ItemSeperator || strType.GetChar(index) == JsWriter.MapEndChar;
                     index++;
                     if (success)
-                        for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                        for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                 }
 
             }
diff --git a/src/ServiceStack.Text/Json/JsonTypeSerializer.cs b/src/ServiceStack.Text/Json/JsonTypeSerializer.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Globalization;
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Text;
 using ServiceStack.Text.Common;
 using ServiceStack.Text.Pools;
@@ -40,16 +41,6 @@ internal static string GetTypeAttrInObject(string typeAttr)
             return string.Format("{{\"{0}\":", typeAttr);
         }
 
-        public static readonly bool[] WhiteSpaceFlags = new bool[' ' + 1];
-
-        static JsonTypeSerializer()
-        {
-            foreach (var c in JsonUtils.WhiteSpaceChars)
-            {
-                WhiteSpaceFlags[c] = true;
-            }
-        }
-
         public WriteObjectDelegate GetWriteFn<T>()
         {
             return JsonWriter<T>.WriteFn();
@@ -365,7 +356,7 @@ public string ParseString(string value)
 
         public static bool IsEmptyMap(StringSegment value, int i = 1)
         {
-            for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (value.Length == i) return true;
             return value.GetChar(i++) == JsWriter.MapEndChar;
         }
@@ -430,7 +421,7 @@ public StringSegment UnescapeSafeString(StringSegment value)
 
         internal static StringSegment ParseJsonString(StringSegment json, ref int index)
         {
-            for (; index < json.Length; index++) { var ch = json.GetChar(index); if (ch >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[ch]) break; } //Whitespace inline
+            for (; index < json.Length; index++) { var ch = json.GetChar(index); if (!JsonUtils.IsWhiteSpace(ch)) break; } //Whitespace inline
 
             return UnEscapeJsonString(json, ref index);
         }
@@ -611,7 +602,7 @@ public StringSegment EatTypeValue(StringSegment value, ref int i)
 
         public bool EatMapStartChar(StringSegment value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             return value.GetChar(i++) == JsWriter.MapStartChar;
         }
 
@@ -620,7 +611,7 @@ public bool EatMapStartChar(StringSegment value, ref int i)
         public StringSegment EatMapKey(StringSegment value, ref int i)
         {
             var valueLength = value.Length;
-            for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
 
             var tokenStartPos = i;
             var valueChar = value.GetChar(i);
@@ -644,7 +635,7 @@ public StringSegment EatMapKey(StringSegment value, ref int i)
 
                 if (valueChar == JsWriter.ItemSeperator
                     //If it doesn't have quotes it's either a keyword or number so also has a ws boundary
-                    || (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])
+                    || (JsonUtils.IsWhiteSpace(valueChar))
                 )
                 {
                     break;
@@ -659,7 +650,7 @@ public StringSegment EatMapKey(StringSegment value, ref int i)
 
         public bool EatMapKeySeperator(StringSegment value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (value.Length == i) return false;
             return value.GetChar(i++) == JsWriter.MapKeySeperator;
         }
@@ -671,7 +662,7 @@ public bool EatItemSeperatorOrMapEndChar(string value, ref int i)
 
         public bool EatItemSeperatorOrMapEndChar(StringSegment value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
 
             if (i == value.Length) return false;
 
@@ -682,20 +673,20 @@ public bool EatItemSeperatorOrMapEndChar(StringSegment value, ref int i)
 
             if (success)
             {
-                for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+                for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             }
 
             return success;
         }
 
         public void EatWhitespace(StringSegment value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
         }
 
         public void EatWhitespace(string value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
         }
 
         public string EatValue(string value, ref int i)
@@ -710,7 +701,7 @@ public StringSegment EatValue(StringSegment value, ref int i)
             var offset = value.Offset;
             if (i == valueLength) return default(StringSegment);
 
-            for (; i < valueLength; i++) { var c = buf[offset + i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = buf[offset + i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (i == valueLength) return default(StringSegment);
 
             var tokenStartPos = i;
@@ -790,7 +781,7 @@ public StringSegment EatValue(StringSegment value, ref int i)
                 if (valueChar == JsWriter.ItemSeperator
                     || valueChar == JsWriter.MapEndChar
                     //If it doesn't have quotes it's either a keyword or number so also has a ws boundary
-                    || (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])
+                    || JsonUtils.IsWhiteSpace(valueChar)
                 )
                 {
                     break;
diff --git a/src/ServiceStack.Text/Json/JsonUtils.cs b/src/ServiceStack.Text/Json/JsonUtils.cs
@@ -1,6 +1,7 @@
 //Copyright (c) Service Stack LLC. All Rights Reserved.
 //License: https://raw.github.com/ServiceStack/ServiceStack/master/license.txt
 
+using System;
 using System.IO;
 using System.Runtime.CompilerServices;
 #if NETSTANDARD1_1
@@ -23,11 +24,12 @@ public static class JsonUtils
         public const string True = "true";
         public const string False = "false";
 
-        private const char TabChar = '\t';
-        private const char CarriageReturnChar = '\r';
-        private const char LineFeedChar = '\n';
-        private const char FormFeedChar = '\f';
-        private const char BackspaceChar = '\b';
+        public const char SpaceChar = ' ';
+        public const char TabChar = '\t';
+        public const char CarriageReturnChar = '\r';
+        public const char LineFeedChar = '\n';
+        public const char FormFeedChar = '\f';
+        public const char BackspaceChar = '\b';
 
         /// <summary>
         /// Micro-optimization keep pre-built char arrays saving a .ToCharArray() + function call (see .net implementation of .Write(string))
@@ -42,6 +44,12 @@ public static class JsonUtils
 
         public static readonly char[] WhiteSpaceChars = { ' ', TabChar, CarriageReturnChar, LineFeedChar };
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsWhiteSpace(char c)
+        {
+            return c == ' ' || (c >= '\x0009' && c <= '\x000d') || c == '\x00a0' || c == '\x0085';
+        }
+
         public static void WriteString(TextWriter writer, string value)
         {
             if (value == null)

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ internal static object StringToType(`
`73`	`73`	`return null;`
`74`	`74`
`75`	`75`	`//if (!Serializer.EatMapStartChar(strType, ref index))`
`76`		`- for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`76`	`+ for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`77`	`77`	`if (strType.GetChar(index++) != JsWriter.MapStartChar)`
`78`	`78`	`throw DeserializeTypeRef.CreateSerializationError(type, strType.Value);`
`79`	`79`
`@@ -91,7 +91,7 @@ internal static object StringToType(`
`91`	`91`	`var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);`
`92`	`92`
`93`	`93`	`//Serializer.EatMapKeySeperator(strType, ref index);`
`94`		`- for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`94`	`+ for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`95`	`95`	`if (strType.Length != index) index++;`
`96`	`96`
`97`	`97`	`var propertyValueStr = Serializer.EatValue(strType, ref index);`
`@@ -165,13 +165,13 @@ internal static object StringToType(`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);`
`168`		`- for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`168`	`+ for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`169`	`169`	`if (index != strType.Length)`
`170`	`170`	`{`
`171`	`171`	`var success = strType.GetChar(index) == JsWriter.ItemSeperator \|\| strType.GetChar(index) == JsWriter.MapEndChar;`
`172`	`172`	`index++;`
`173`	`173`	`if (success)`
`174`		`- for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`174`	`+ for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`continue;`
`@@ -208,13 +208,13 @@ internal static object StringToType(`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);`
`211`		`- for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`211`	`+ for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`212`	`212`	`if (index != strType.Length)`
`213`	`213`	`{`
`214`	`214`	`var success = strType.GetChar(index) == JsWriter.ItemSeperator \|\| strType.GetChar(index) == JsWriter.MapEndChar;`
`215`	`215`	`index++;`
`216`	`216`	`if (success)`
`217`		`- for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`217`	`+ for (; index < strType.Length; index++) { var c = strType.GetChar(index); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System;`
`5`	`5`	`using System.Globalization;`
`6`	`6`	`using System.IO;`
	`7`	`+using System.Runtime.CompilerServices;`
`7`	`8`	`using System.Text;`
`8`	`9`	`using ServiceStack.Text.Common;`
`9`	`10`	`using ServiceStack.Text.Pools;`
`@@ -40,16 +41,6 @@ internal static string GetTypeAttrInObject(string typeAttr)`
`40`	`41`	`return string.Format("{{\"{0}\":", typeAttr);`
`41`	`42`	`}`
`42`	`43`
`43`		`- public static readonly bool[] WhiteSpaceFlags = new bool[' ' + 1];`
`44`		`-`
`45`		`- static JsonTypeSerializer()`
`46`		`- {`
`47`		`- foreach (var c in JsonUtils.WhiteSpaceChars)`
`48`		`- {`
`49`		`- WhiteSpaceFlags[c] = true;`
`50`		`- }`
`51`		`- }`
`52`		`-`
`53`	`44`	`public WriteObjectDelegate GetWriteFn<T>()`
`54`	`45`	`{`
`55`	`46`	`return JsonWriter<T>.WriteFn();`
`@@ -365,7 +356,7 @@ public string ParseString(string value)`
`365`	`356`
`366`	`357`	`public static bool IsEmptyMap(StringSegment value, int i = 1)`
`367`	`358`	`{`
`368`		`- for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`359`	`+ for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`369`	`360`	`if (value.Length == i) return true;`
`370`	`361`	`return value.GetChar(i++) == JsWriter.MapEndChar;`
`371`	`362`	`}`
`@@ -430,7 +421,7 @@ public StringSegment UnescapeSafeString(StringSegment value)`
`430`	`421`
`431`	`422`	`internal static StringSegment ParseJsonString(StringSegment json, ref int index)`
`432`	`423`	`{`
`433`		`- for (; index < json.Length; index++) { var ch = json.GetChar(index); if (ch >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[ch]) break; } //Whitespace inline`
	`424`	`+ for (; index < json.Length; index++) { var ch = json.GetChar(index); if (!JsonUtils.IsWhiteSpace(ch)) break; } //Whitespace inline`
`434`	`425`
`435`	`426`	`return UnEscapeJsonString(json, ref index);`
`436`	`427`	`}`
`@@ -611,7 +602,7 @@ public StringSegment EatTypeValue(StringSegment value, ref int i)`
`611`	`602`
`612`	`603`	`public bool EatMapStartChar(StringSegment value, ref int i)`
`613`	`604`	`{`
`614`		`- for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`605`	`+ for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`615`	`606`	`return value.GetChar(i++) == JsWriter.MapStartChar;`
`616`	`607`	`}`
`617`	`608`
`@@ -620,7 +611,7 @@ public bool EatMapStartChar(StringSegment value, ref int i)`
`620`	`611`	`public StringSegment EatMapKey(StringSegment value, ref int i)`
`621`	`612`	`{`
`622`	`613`	`var valueLength = value.Length;`
`623`		`- for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`614`	`+ for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`624`	`615`
`625`	`616`	`var tokenStartPos = i;`
`626`	`617`	`var valueChar = value.GetChar(i);`
`@@ -644,7 +635,7 @@ public StringSegment EatMapKey(StringSegment value, ref int i)`
`644`	`635`
`645`	`636`	`if (valueChar == JsWriter.ItemSeperator`
`646`	`637`	`//If it doesn't have quotes it's either a keyword or number so also has a ws boundary`
`647`		`- \|\| (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])`
	`638`	`+ \|\| (JsonUtils.IsWhiteSpace(valueChar))`
`648`	`639`	`)`
`649`	`640`	`{`
`650`	`641`	`break;`
`@@ -659,7 +650,7 @@ public StringSegment EatMapKey(StringSegment value, ref int i)`
`659`	`650`
`660`	`651`	`public bool EatMapKeySeperator(StringSegment value, ref int i)`
`661`	`652`	`{`
`662`		`- for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`653`	`+ for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`663`	`654`	`if (value.Length == i) return false;`
`664`	`655`	`return value.GetChar(i++) == JsWriter.MapKeySeperator;`
`665`	`656`	`}`
`@@ -671,7 +662,7 @@ public bool EatItemSeperatorOrMapEndChar(string value, ref int i)`
`671`	`662`
`672`	`663`	`public bool EatItemSeperatorOrMapEndChar(StringSegment value, ref int i)`
`673`	`664`	`{`
`674`		`- for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`665`	`+ for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`675`	`666`
`676`	`667`	`if (i == value.Length) return false;`
`677`	`668`
`@@ -682,20 +673,20 @@ public bool EatItemSeperatorOrMapEndChar(StringSegment value, ref int i)`
`682`	`673`
`683`	`674`	`if (success)`
`684`	`675`	`{`
`685`		`- for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`676`	`+ for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`686`	`677`	`}`
`687`	`678`
`688`	`679`	`return success;`
`689`	`680`	`}`
`690`	`681`
`691`	`682`	`public void EatWhitespace(StringSegment value, ref int i)`
`692`	`683`	`{`
`693`		`- for (; i < value.Length; i++) { var c = value.GetChar(i); if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`684`	`+ for (; i < value.Length; i++) { var c = value.GetChar(i); if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`694`	`685`	`}`
`695`	`686`
`696`	`687`	`public void EatWhitespace(string value, ref int i)`
`697`	`688`	`{`
`698`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`689`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`699`	`690`	`}`
`700`	`691`
`701`	`692`	`public string EatValue(string value, ref int i)`
`@@ -710,7 +701,7 @@ public StringSegment EatValue(StringSegment value, ref int i)`
`710`	`701`	`var offset = value.Offset;`
`711`	`702`	`if (i == valueLength) return default(StringSegment);`
`712`	`703`
`713`		`- for (; i < valueLength; i++) { var c = buf[offset + i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`704`	`+ for (; i < value.Length; i++) { var c = buf[offset + i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`714`	`705`	`if (i == valueLength) return default(StringSegment);`
`715`	`706`
`716`	`707`	`var tokenStartPos = i;`
`@@ -790,7 +781,7 @@ public StringSegment EatValue(StringSegment value, ref int i)`
`790`	`781`	`if (valueChar == JsWriter.ItemSeperator`
`791`	`782`	`\|\| valueChar == JsWriter.MapEndChar`
`792`	`783`	`//If it doesn't have quotes it's either a keyword or number so also has a ws boundary`
`793`		`- \|\| (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])`
	`784`	`+ \|\| JsonUtils.IsWhiteSpace(valueChar)`
`794`	`785`	`)`
`795`	`786`	`{`
`796`	`787`	`break;`