json-as 0.9.27 → 0.9.29

package/assembly/deserialize/map.ts

@@ -1,24 +1,6 @@
 import { Virtual } from "as-virtual/assembly";
 import { containsCodePoint, unsafeCharCodeAt } from "../custom/util";
-import {
-    CHAR_A,
-    BACK_SLASH,
-    COLON,
-    COMMA,
-    CHAR_E,
-    CHAR_F,
-    CHAR_L,
-    BRACE_LEFT,
-    BRACKET_LEFT,
-    CHAR_N,
-    QUOTE,
-    CHAR_R,
-    BRACE_RIGHT,
-    BRACKET_RIGHT,
-    CHAR_S,
-    CHAR_T,
-    CHAR_U
-} from "../custom/chars";
+import { CHAR_A, BACK_SLASH, COLON, COMMA, CHAR_E, CHAR_F, CHAR_L, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, CHAR_R, BRACE_RIGHT, BRACKET_RIGHT, CHAR_S, CHAR_T, CHAR_U } from "../custom/chars";
 import { deserializeBoolean } from "./bool";
 import { JSON } from "..";
 import { deserializeString } from "./string";
@@ -28,162 +10,130 @@ import { deserializeFloat } from "./float";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeMap<T extends Map>(data: string): T {
+  const map: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
 
-    const map: nonnull<T> = changetype<nonnull<T>>(
-        __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
-    );
-
-    const key = Virtual.createEmpty<string>();
-    let isKey = false;
-    let depth = 0;
-    let outerLoopIndex = 1;
-    for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
-        const char = unsafeCharCodeAt(data, outerLoopIndex);
+  const key = Virtual.createEmpty<string>();
+  let isKey = false;
+  let depth = 0;
+  let outerLoopIndex = 1;
+  for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
+    const char = unsafeCharCodeAt(data, outerLoopIndex);
+    if (char === BRACKET_LEFT) {
+      for (let arrayValueIndex = outerLoopIndex; arrayValueIndex < data.length - 1; arrayValueIndex++) {
+        const char = unsafeCharCodeAt(data, arrayValueIndex);
         if (char === BRACKET_LEFT) {
-            for (
-                let arrayValueIndex = outerLoopIndex;
-                arrayValueIndex < data.length - 1;
-                arrayValueIndex++
-            ) {
-                const char = unsafeCharCodeAt(data, arrayValueIndex);
-                if (char === BRACKET_LEFT) {
-                    depth++;
-                } else if (char === BRACKET_RIGHT) {
-                    depth--;
-                    if (depth === 0) {
-                        ++arrayValueIndex;
-                        map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, arrayValueIndex)));
-                        outerLoopIndex = arrayValueIndex;
-                        isKey = false;
-                        break;
-                    }
-                }
-            }
-        } else if (char === BRACE_LEFT) {
-            for (
-                let objectValueIndex = outerLoopIndex;
-                objectValueIndex < data.length - 1;
-                objectValueIndex++
-            ) {
-                const char = unsafeCharCodeAt(data, objectValueIndex);
-                if (char === BRACE_LEFT) {
-                    depth++;
-                } else if (char === BRACE_RIGHT) {
-                    depth--;
-                    if (depth === 0) {
-                        ++objectValueIndex;
-                        map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, objectValueIndex)));
-                        outerLoopIndex = objectValueIndex;
-                        isKey = false;
-                        break;
-                    }
-                }
-            }
-        } else if (char === QUOTE) {
-            let escaping = false;
-            for (
-                let stringValueIndex = ++outerLoopIndex;
-                stringValueIndex < data.length - 1;
-                stringValueIndex++
-            ) {
-                const char = unsafeCharCodeAt(data, stringValueIndex);
-                if (char === BACK_SLASH && !escaping) {
-                    escaping = true;
-                } else {
-                    if (
-                        char === QUOTE && !escaping
-                    ) {
-                        if (isKey === false) {
-                            // perf: we can avoid creating a new string here if the key doesn't contain any escape sequences
-                            if (containsCodePoint(data, BACK_SLASH, outerLoopIndex, stringValueIndex)) {
-                                key.reinst(deserializeString(data, outerLoopIndex - 1, stringValueIndex));
-                            } else {
-                                key.reinst(data, outerLoopIndex, stringValueIndex);
-                            }
-                            isKey = true;
-                        } else {
-                            if (isString<valueof<T>>()) {
-                                const value = deserializeString(data, outerLoopIndex - 1, stringValueIndex);
-                                map.set(deserializeMapKey<indexof<T>>(key), value);
-                            }
-                            isKey = false;
-                        }
-                        outerLoopIndex = ++stringValueIndex;
-                        break;
-                    }
-                    escaping = false;
-                }
-            }
-        } else if (
-            char == CHAR_N &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_U &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_L &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_L) {
-            if (isNullable<valueof<T>>()) {
-                map.set(deserializeMapKey<indexof<T>>(key), null);
-            }
-            isKey = false;
-        } else if (
-            char === CHAR_T &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_R &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_U &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_E
-        ) {
-            if (isBoolean<valueof<T>>()) {
-                map.set(deserializeMapKey<indexof<T>>(key), true);
-            }
+          depth++;
+        } else if (char === BRACKET_RIGHT) {
+          depth--;
+          if (depth === 0) {
+            ++arrayValueIndex;
+            map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, arrayValueIndex)));
+            outerLoopIndex = arrayValueIndex;
             isKey = false;
-        } else if (
-            char === CHAR_F &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_A &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_L &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_S &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_E
-        ) {
-            if (isBoolean<valueof<T>>()) {
-                map.set(deserializeMapKey<indexof<T>>(key), false);
-            }
+            break;
+          }
+        }
+      }
+    } else if (char === BRACE_LEFT) {
+      for (let objectValueIndex = outerLoopIndex; objectValueIndex < data.length - 1; objectValueIndex++) {
+        const char = unsafeCharCodeAt(data, objectValueIndex);
+        if (char === BRACE_LEFT) {
+          depth++;
+        } else if (char === BRACE_RIGHT) {
+          depth--;
+          if (depth === 0) {
+            ++objectValueIndex;
+            map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, objectValueIndex)));
+            outerLoopIndex = objectValueIndex;
             isKey = false;
-        } else if ((char >= 48 && char <= 57) || char === 45) {
-            let numberValueIndex = ++outerLoopIndex;
-            for (; numberValueIndex < data.length; numberValueIndex++) {
-                const char = unsafeCharCodeAt(data, numberValueIndex);
-                if (char === COLON || char === COMMA || char === BRACE_RIGHT || isSpace(char)) {
-                    if (isInteger<valueof<T>>()) {
-                        map.set(deserializeMapKey<indexof<T>>(key), deserializeInteger<valueof<T>>(data.slice(outerLoopIndex - 1, numberValueIndex)));
-                    } else if (isFloat<valueof<T>>()) {
-                        map.set(deserializeMapKey<indexof<T>>(key), deserializeFloat<valueof<T>>(data.slice(outerLoopIndex - 1, numberValueIndex)));
-                    }
-                    outerLoopIndex = numberValueIndex;
-                    isKey = false;
-                    break;
-                }
+            break;
+          }
+        }
+      }
+    } else if (char === QUOTE) {
+      let escaping = false;
+      for (let stringValueIndex = ++outerLoopIndex; stringValueIndex < data.length - 1; stringValueIndex++) {
+        const char = unsafeCharCodeAt(data, stringValueIndex);
+        if (char === BACK_SLASH && !escaping) {
+          escaping = true;
+        } else {
+          if (char === QUOTE && !escaping) {
+            if (isKey === false) {
+              // perf: we can avoid creating a new string here if the key doesn't contain any escape sequences
+              if (containsCodePoint(data, BACK_SLASH, outerLoopIndex, stringValueIndex)) {
+                key.reinst(deserializeString(data, outerLoopIndex - 1, stringValueIndex));
+              } else {
+                key.reinst(data, outerLoopIndex, stringValueIndex);
+              }
+              isKey = true;
+            } else {
+              if (isString<valueof<T>>()) {
+                const value = deserializeString(data, outerLoopIndex - 1, stringValueIndex);
+                map.set(deserializeMapKey<indexof<T>>(key), value);
+              }
+              isKey = false;
             }
+            outerLoopIndex = ++stringValueIndex;
+            break;
+          }
+          escaping = false;
         }
+      }
+    } else if (char == CHAR_N && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_U && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_L && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_L) {
+      if (isNullable<valueof<T>>()) {
+        map.set(deserializeMapKey<indexof<T>>(key), null);
+      }
+      isKey = false;
+    } else if (char === CHAR_T && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_R && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_U && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_E) {
+      if (isBoolean<valueof<T>>()) {
+        map.set(deserializeMapKey<indexof<T>>(key), true);
+      }
+      isKey = false;
+    } else if (char === CHAR_F && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_A && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_L && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_S && unsafeCharCodeAt(data, ++outerLoopIndex) === CHAR_E) {
+      if (isBoolean<valueof<T>>()) {
+        map.set(deserializeMapKey<indexof<T>>(key), false);
+      }
+      isKey = false;
+    } else if ((char >= 48 && char <= 57) || char === 45) {
+      let numberValueIndex = ++outerLoopIndex;
+      for (; numberValueIndex < data.length; numberValueIndex++) {
+        const char = unsafeCharCodeAt(data, numberValueIndex);
+        if (char === COLON || char === COMMA || char === BRACE_RIGHT || isSpace(char)) {
+          if (isInteger<valueof<T>>()) {
+            map.set(deserializeMapKey<indexof<T>>(key), deserializeInteger<valueof<T>>(data.slice(outerLoopIndex - 1, numberValueIndex)));
+          } else if (isFloat<valueof<T>>()) {
+            map.set(deserializeMapKey<indexof<T>>(key), deserializeFloat<valueof<T>>(data.slice(outerLoopIndex - 1, numberValueIndex)));
+          }
+          outerLoopIndex = numberValueIndex;
+          isKey = false;
+          break;
+        }
+      }
     }
+  }
 
-    return map;
+  return map;
 }
 
 //@ts-ignore: Decorator
 function deserializeMapKey<T>(key: Virtual<string>): T {
-    const k = key.copyOut();
-    if (isString<T>()) {
-        return k as T;
-    } else if (isBoolean<T>()) {
-        return deserializeBoolean(k) as T;
-    } else if (isInteger<T>()) {
-        return deserializeInteger<T>(k);
-    } else if (isFloat<T>()) {
-        return deserializeFloat<T>(k);
-    }
+  const k = key.copyOut();
+  if (isString<T>()) {
+    return k as T;
+  } else if (isBoolean<T>()) {
+    return deserializeBoolean(k) as T;
+  } else if (isInteger<T>()) {
+    return deserializeInteger<T>(k);
+  } else if (isFloat<T>()) {
+    return deserializeFloat<T>(k);
+  }
 
-    throw new Error(`JSON: Cannot parse JSON object to a Map with a key of type ${nameof<T>()}`);
+  throw new Error(`JSON: Cannot parse JSON object to a Map with a key of type ${nameof<T>()}`);
 }
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeMap_Safe<T extends Map>(data: string): T {
-    const firstChar = load<u8>(changetype<usize>(data));
-    if (firstChar != BRACE_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \"" + data.slice(0, 100) + "\" instead!");
-    return deserializeMap<T>(data);
-}
+  const firstChar = load<u8>(changetype<usize>(data));
+  if (firstChar != BRACE_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + ' but got "' + data.slice(0, 100) + '" instead!');
+  return deserializeMap<T>(data);
+}

package/assembly/deserialize/object.ts

@@ -4,9 +4,7 @@ import { isSpace } from "util/string";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeObject<T>(data: string): T {
-  const schema: nonnull<T> = changetype<nonnull<T>>(
-    __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
-  );
+  const schema: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
 
   // @ts-ignore
   schema.__INITIALIZE();
@@ -19,11 +17,7 @@ import { isSpace } from "util/string";
   for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
     const char = unsafeCharCodeAt(data, outerLoopIndex);
     if (char === BRACKET_LEFT) {
-      for (
-        let arrayValueIndex = outerLoopIndex;
-        arrayValueIndex < data.length - 1;
-        arrayValueIndex++
-      ) {
+      for (let arrayValueIndex = outerLoopIndex; arrayValueIndex < data.length - 1; arrayValueIndex++) {
         const char = unsafeCharCodeAt(data, arrayValueIndex);
         if (char === BRACKET_LEFT) {
           depth++;
@@ -40,11 +34,7 @@ import { isSpace } from "util/string";
         }
       }
     } else if (char === BRACE_LEFT) {
-      for (
-        let objectValueIndex = outerLoopIndex;
-        objectValueIndex < data.length - 1;
-        objectValueIndex++
-      ) {
+      for (let objectValueIndex = outerLoopIndex; objectValueIndex < data.length - 1; objectValueIndex++) {
         const char = unsafeCharCodeAt(data, objectValueIndex);
         if (char === BRACE_LEFT) {
           depth++;
@@ -62,11 +52,7 @@ import { isSpace } from "util/string";
       }
     } else if (char === QUOTE) {
       let escaping = false;
-      for (
-        let stringValueIndex = ++outerLoopIndex;
-        stringValueIndex < data.length - 1;
-        stringValueIndex++
-      ) {
+      for (let stringValueIndex = ++outerLoopIndex; stringValueIndex < data.length - 1; stringValueIndex++) {
         const char = unsafeCharCodeAt(data, stringValueIndex);
         if (char === BACK_SLASH && !escaping) {
           escaping = true;
@@ -87,33 +73,17 @@ import { isSpace } from "util/string";
           escaping = false;
         }
       }
-    } else if (
-      char == CHAR_N &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_U &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_L
-    ) {
+    } else if (char == CHAR_N && unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_U && unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L && unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_L) {
       // @ts-ignore
       schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
       outerLoopIndex += 3;
       isKey = false;
-    } else if (
-      char === CHAR_T &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_R &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_U &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_E
-    ) {
+    } else if (char === CHAR_T && unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_R && unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_U && unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_E) {
       // @ts-ignore
       schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
       outerLoopIndex += 3;
       isKey = false;
-    } else if (
-      char === CHAR_F &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_A &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_S &&
-      unsafeCharCodeAt(data, outerLoopIndex + 4) === CHAR_E
-    ) {
+    } else if (char === CHAR_F && unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_A && unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L && unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_S && unsafeCharCodeAt(data, outerLoopIndex + 4) === CHAR_E) {
       // @ts-ignore
       schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 5);
       outerLoopIndex += 4;
@@ -138,10 +108,8 @@ import { isSpace } from "util/string";
 // @ts-ignore: Decorator valid here
 @inline export function deserializeObject_Safe<T>(data: string): T {
   const firstChar = load<u8>(changetype<usize>(data));
-  if (firstChar != BRACE_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \"" + data.slice(0, 100) + "\" instead!");
-  const schema: nonnull<T> = changetype<nonnull<T>>(
-    __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
-  );
+  if (firstChar != BRACE_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + ' but got "' + data.slice(0, 100) + '" instead!');
+  const schema: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
 
   // @ts-ignore
   schema.__INITIALIZE();
@@ -154,11 +122,7 @@ import { isSpace } from "util/string";
   for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
     const char = unsafeCharCodeAt(data, outerLoopIndex);
     if (char === BRACKET_LEFT) {
-      for (
-        let arrayValueIndex = outerLoopIndex;
-        arrayValueIndex < data.length - 1;
-        arrayValueIndex++
-      ) {
+      for (let arrayValueIndex = outerLoopIndex; arrayValueIndex < data.length - 1; arrayValueIndex++) {
         const char = unsafeCharCodeAt(data, arrayValueIndex);
         if (char === BRACKET_LEFT) {
           depth++;
@@ -175,11 +139,7 @@ import { isSpace } from "util/string";
         }
       }
     } else if (char === BRACE_LEFT) {
-      for (
-        let objectValueIndex = outerLoopIndex;
-        objectValueIndex < data.length - 1;
-        objectValueIndex++
-      ) {
+      for (let objectValueIndex = outerLoopIndex; objectValueIndex < data.length - 1; objectValueIndex++) {
         const char = unsafeCharCodeAt(data, objectValueIndex);
         if (char === BRACE_LEFT) {
           depth++;
@@ -197,11 +157,7 @@ import { isSpace } from "util/string";
       }
     } else if (char === QUOTE) {
       let escaping = false;
-      for (
-        let stringValueIndex = ++outerLoopIndex;
-        stringValueIndex < data.length - 1;
-        stringValueIndex++
-      ) {
+      for (let stringValueIndex = ++outerLoopIndex; stringValueIndex < data.length - 1; stringValueIndex++) {
         const char = unsafeCharCodeAt(data, stringValueIndex);
         if (char === BACK_SLASH && !escaping) {
           escaping = true;
@@ -222,33 +178,17 @@ import { isSpace } from "util/string";
           escaping = false;
         }
       }
-    } else if (
-      char == CHAR_N &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_U &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_L
-    ) {
+    } else if (char == CHAR_N && unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_U && unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L && unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_L) {
       // @ts-ignore
       schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
       outerLoopIndex += 3;
       isKey = false;
-    } else if (
-      char === CHAR_T &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_R &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_U &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_E
-    ) {
+    } else if (char === CHAR_T && unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_R && unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_U && unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_E) {
       // @ts-ignore
       schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
       outerLoopIndex += 3;
       isKey = false;
-    } else if (
-      char === CHAR_F &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_A &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_S &&
-      unsafeCharCodeAt(data, outerLoopIndex + 4) === CHAR_E
-    ) {
+    } else if (char === CHAR_F && unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_A && unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L && unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_S && unsafeCharCodeAt(data, outerLoopIndex + 4) === CHAR_E) {
       // @ts-ignore
       schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 5);
       outerLoopIndex += 4;
@@ -268,4 +208,4 @@ import { isSpace } from "util/string";
     }
   }
   return schema;
-}
+}

package/assembly/deserialize/string.ts

@@ -1,90 +1,75 @@
-import {
-    CHAR_B,
-    BACK_SLASH,
-    BACKSPACE,
-    CARRIAGE_RETURN,
-    CHAR_F,
-    FORM_FEED,
-    FWD_SLASH,
-    CHAR_N,
-    NEW_LINE,
-    QUOTE,
-    CHAR_R,
-    CHAR_T,
-    TAB,
-    CHAR_U
-} from "../custom/chars";
+import { CHAR_B, BACK_SLASH, BACKSPACE, CARRIAGE_RETURN, CHAR_F, FORM_FEED, FWD_SLASH, CHAR_N, NEW_LINE, QUOTE, CHAR_R, CHAR_T, TAB, CHAR_U } from "../custom/chars";
 import { Sink } from "../custom/sink";
 import { unsafeCharCodeAt } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeString(data: string, start: i32 = 0, end: i32 = 0): string {
-    end = end || data.length - 1;
-    let result = Sink.withCapacity(end - start - 1);
-    let last = start + 1;
-    for (let i = last; i < end; i++) {
-        if (unsafeCharCodeAt(data, i) !== BACK_SLASH) {
-            continue;
-        }
-        const char = unsafeCharCodeAt(data, ++i);
-        result.write(data, last, i - 1);
-        switch (char) {
-            case QUOTE: {
-                result.writeCodePoint(QUOTE);
-                last = i + 1;
-                break;
-            }
-            case BACK_SLASH: {
-                result.writeCodePoint(BACK_SLASH);
-                last = i + 1;
-                break;
-            }
-            case FWD_SLASH: {
-                result.writeCodePoint(FWD_SLASH);
-                last = i + 1;
-                break;
-            }
-            case CHAR_B: {
-                result.writeCodePoint(BACKSPACE);
-                last = i + 1;
-                break;
-            }
-            case CHAR_F: {
-                result.writeCodePoint(FORM_FEED);
-                last = i + 1;
-                break;
-            }
-            case CHAR_N: {
-                result.writeCodePoint(NEW_LINE);
-                last = i + 1;
-                break;
-            }
-            case CHAR_R: {
-                result.writeCodePoint(CARRIAGE_RETURN);
-                last = i + 1;
-                break;
-            }
-            case CHAR_T: {
-                result.writeCodePoint(TAB);
-                last = i + 1;
-                break;
-            }
-            case CHAR_U: {
-                const code = u16.parse(data.slice(i + 1, i + 5), 16);
-                result.writeCodePoint(code);
-                i += 4;
-                last = i + 1;
-                break;
-            }
-            default: {
-                throw new Error(`JSON: Cannot parse "${data}" as string. Invalid escape sequence: \\${data.charAt(i)}`);
-            }
-        }
+  end = end || data.length - 1;
+  let result = Sink.withCapacity(end - start - 1);
+  let last = start + 1;
+  for (let i = last; i < end; i++) {
+    if (unsafeCharCodeAt(data, i) !== BACK_SLASH) {
+      continue;
     }
-    if (end > last) {
-        result.write(data, last, end);
+    const char = unsafeCharCodeAt(data, ++i);
+    result.write(data, last, i - 1);
+    switch (char) {
+      case QUOTE: {
+        result.writeCodePoint(QUOTE);
+        last = i + 1;
+        break;
+      }
+      case BACK_SLASH: {
+        result.writeCodePoint(BACK_SLASH);
+        last = i + 1;
+        break;
+      }
+      case FWD_SLASH: {
+        result.writeCodePoint(FWD_SLASH);
+        last = i + 1;
+        break;
+      }
+      case CHAR_B: {
+        result.writeCodePoint(BACKSPACE);
+        last = i + 1;
+        break;
+      }
+      case CHAR_F: {
+        result.writeCodePoint(FORM_FEED);
+        last = i + 1;
+        break;
+      }
+      case CHAR_N: {
+        result.writeCodePoint(NEW_LINE);
+        last = i + 1;
+        break;
+      }
+      case CHAR_R: {
+        result.writeCodePoint(CARRIAGE_RETURN);
+        last = i + 1;
+        break;
+      }
+      case CHAR_T: {
+        result.writeCodePoint(TAB);
+        last = i + 1;
+        break;
+      }
+      case CHAR_U: {
+        const code = u16.parse(data.slice(i + 1, i + 5), 16);
+        result.writeCodePoint(code);
+        i += 4;
+        last = i + 1;
+        break;
+      }
+      default: {
+        throw new Error(`JSON: Cannot parse "${data}" as string. Invalid escape sequence: \\${data.charAt(i)}`);
+      }
     }
-    return result.toString()
+  }
+  if (end > last) {
+    result.write(data, last, end);
+  }
+  return result.toString();
 }
 
 // @ts-ignore: Decorator valid here
@@ -139,7 +124,7 @@ import { unsafeCharCodeAt } from "../custom/util";
 //                 break;
 //             }
 //             case CHAR_U: {
-                
+
 //                 const code = u16.parse(data.slice(i + 1, i + 5), 16);
 //                 bs.w(code);
 //                 i += 4;
@@ -158,7 +143,7 @@ import { unsafeCharCodeAt } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeString_Safe(data: string, start: i32 = 0, end: i32 = 0): string {
-    const firstChar = load<u8>(changetype<usize>(data));
-    if (firstChar != QUOTE) throw new Error("Mismatched Types! Expected string but got \""+data.slice(0, 100)+"\" instead!");
-    return deserializeString(data, start, end);
-}
+  const firstChar = load<u8>(changetype<usize>(data));
+  if (firstChar != QUOTE) throw new Error('Mismatched Types! Expected string but got "' + data.slice(0, 100) + '" instead!');
+  return deserializeString(data, start, end);
+}