json-as 0.9.28 → 0.9.29

package/assembly/custom/util.ts

@@ -21,10 +21,7 @@ export function isMap<T>(): bool {
   for (let i = 0; i < data.length; i++) {
     const char = unsafeCharCodeAt(data, i);
     if (instr === false && char === QUOTE) instr = true;
-    else if (
-      instr === true && char === QUOTE
-      && unsafeCharCodeAt(data, i - 1) !== BACK_SLASH
-    ) instr = false;
+    else if (instr === true && char === QUOTE && unsafeCharCodeAt(data, i - 1) !== BACK_SLASH) instr = false;
 
     if (instr === false) {
       if (!isSpace(char)) result.write(data.charAt(i));
@@ -82,17 +79,17 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
  * Loads 32 bits and retrieves the high/low bits.
  * The reason why we only load 4 bytes at a time is that numbers in the 32-bit range are 7 chars long at most.
  * Using SIMD or 64 bit loads would only work well when parsing large 128+ numbers.
- * 
+ *
  * Here are some benchmarks
- * Parsing: "12345" 
+ * Parsing: "12345"
  * Results are spread over 5000ms
- * 
+ *
  * SNIP: 270M iterations
  * ATOI: 285M iterations
- * ParseInt: 176M iterations 
- * 
+ * ParseInt: 176M iterations
+ *
  * @param str - Any number. Can include scientific notation.
-*/
+ */
 // @ts-ignore: Decorator
 @inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
   if (isSigned<T>()) {
@@ -105,31 +102,31 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
       offset += 2;
       if (len >= 4) {
         // 32-bit route
-        for (; offset < (len - 3); offset += 4) {
+        for (; offset < len - 3; offset += 4) {
           const ch = load<u32>(changetype<usize>(str) + <usize>offset);
-          const low = ch & 0xFFFF;
+          const low = ch & 0xffff;
           const high = ch >> 16;
           // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
           if (low > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
-            val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+            val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
           }
         }
       }
@@ -141,43 +138,43 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+            return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else {
-          val = (val * 10) + (ch - 48) as T;
+          val = (val * 10 + (ch - 48)) as T;
         }
       }
       return -val as T;
     } else {
       if (len >= 4) {
         // Duplet 16 bit lane load
-        for (; offset < (len - 3); offset += 4) {
+        for (; offset < len - 3; offset += 4) {
           const ch = load<u32>(changetype<usize>(str) + <usize>offset);
-          const low = ch & 0xFFFF;
+          const low = ch & 0xffff;
           const high = ch >> 16;
           // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
           if (low > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
             // Optimized with multiplications and shifts.
-            val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+            val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
           }
         }
       }
@@ -188,14 +185,14 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
         // e is 101 and E is 69.
         if (ch > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            val = (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            val = (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            val = (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+            val = (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
           return val as T;
         } else {
-          val = (val * 10) + (ch - 48) as T;
+          val = (val * 10 + (ch - 48)) as T;
         }
       }
       return val as T;
@@ -207,30 +204,30 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
     if (len == 0) len = u32(str.length << 1);
     if (len >= 4) {
       // Duplet 16 bit lane load
-      for (; offset < (len - 3); offset += 4) {
+      for (; offset < len - 3; offset += 4) {
         const ch = load<u32>(changetype<usize>(str) + <usize>offset);
-        const low = ch & 0xFFFF;
+        const low = ch & 0xffff;
         const high = ch >> 16;
         // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
         if (low > 57) {
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else if (high > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
           }
         } else {
           // Optimized with multiplications and shifts.
-          val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+          val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
         }
       }
     }
@@ -241,13 +238,13 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
       // e is 101 and E is 69.
       if (ch > 57) {
         if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-          return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+          return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
         } else {
           // Inlined this operation instead of using a loop
-          return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+          return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
         }
       } else {
-        val = (val * 10) + (ch - 48) as T;
+        val = (val * 10 + (ch - 48)) as T;
       }
     }
     return val as T;
@@ -268,18 +265,18 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
     if (load<u16>(changetype<usize>(str) + <usize>start) === 45) {
       start += 2;
       for (; start < end; start += 2) {
-        val = (val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return -val as T;
     } else {
       for (; start < end; start += 2) {
-        val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return val as T;
     }
   } else {
     for (; start < end; start += 2) {
-      val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+      val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
     }
     return val as T;
   }
@@ -351,7 +348,7 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   const p2_len = p2_end - p2_start;
   if (p1_len != p2_len) return false;
   if (p1_len == 2) {
-    return load<u16>(changetype<usize>(p1_data) + p1_start) == load<u16>(changetype<usize>(p2_data) + p2_start)
+    return load<u16>(changetype<usize>(p1_data) + p1_start) == load<u16>(changetype<usize>(p2_data) + p2_start);
   }
   return memory.compare(changetype<usize>(p1_data) + p1_start, changetype<usize>(p2_data) + p2_start, p1_len) === 0;
 }
@@ -378,18 +375,18 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
 // @ts-ignore: Decorator
 @inline export function intTo16(int: i32): i32 {
   const high = int >> 4;
-  const low = int & 0x0F;
+  const low = int & 0x0f;
   if (low < 10) {
     if (high < 10) {
-      return ((48 + low) << 16) | 48 + high;
+      return ((48 + low) << 16) | (48 + high);
     } else {
-      return ((48 + low) << 16) | 87 + high;
+      return ((48 + low) << 16) | (87 + high);
     }
   } else {
     if (high < 10) {
-      return ((87 + low) << 16) | 48 + high;
+      return ((87 + low) << 16) | (48 + high);
     } else {
-      return ((87 + low) << 16) | 87 + high;
+      return ((87 + low) << 16) | (87 + high);
     }
   }
-}
+}

package/assembly/deserialize/array/array.ts

@@ -4,28 +4,28 @@ import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeArrayArray<T extends unknown[][]>(data: string): T {
-    const result = instantiate<T>();
-    let lastPos = 0;
-    let depth = 0;
-    let i = 1;
-    // Find start of bracket
-    //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
-    //i++;
-    for (; i < data.length - 1; i++) {
-        const char = unsafeCharCodeAt(data, i);
-        if (char === BRACKET_LEFT) {
-            if (depth === 0) {
-                lastPos = i;
-            }
-            // Shifting is 6% faster than incrementing
-            depth++;
-        } else if (char === BRACKET_RIGHT) {
-            depth--;
-            if (depth === 0) {
-                i++;
-                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
-            }
-        }
+  const result = instantiate<T>();
+  let lastPos = 0;
+  let depth = 0;
+  let i = 1;
+  // Find start of bracket
+  //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
+  //i++;
+  for (; i < data.length - 1; i++) {
+    const char = unsafeCharCodeAt(data, i);
+    if (char === BRACKET_LEFT) {
+      if (depth === 0) {
+        lastPos = i;
+      }
+      // Shifting is 6% faster than incrementing
+      depth++;
+    } else if (char === BRACKET_RIGHT) {
+      depth--;
+      if (depth === 0) {
+        i++;
+        result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+      }
     }
-    return result;
-}
+  }
+  return result;
+}

package/assembly/deserialize/array/bool.ts

@@ -16,4 +16,4 @@ import { deserializeBoolean } from "../bool";
     }
   }
   return result;
-}
+}

package/assembly/deserialize/array/float.ts

@@ -5,20 +5,20 @@ import { deserializeFloat } from "../float";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeFloatArray<T extends number[]>(data: string): T {
-    const result = instantiate<T>();
-    let lastPos = 0;
-    let i = 1;
-    let awaitingParse = false;
-    for (; i < data.length; i++) {
-      const char = unsafeCharCodeAt(data, i);
-      if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
-        awaitingParse = true;
-        lastPos = i;
-      } else if (awaitingParse && (isSpace(char) || char == COMMA || char == BRACKET_RIGHT) && lastPos > 0) {
-        awaitingParse = false;
-        result.push(deserializeFloat<valueof<T>>(data.slice(lastPos, i)));
-        lastPos = 0;
-      }
+  const result = instantiate<T>();
+  let lastPos = 0;
+  let i = 1;
+  let awaitingParse = false;
+  for (; i < data.length; i++) {
+    const char = unsafeCharCodeAt(data, i);
+    if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
+      awaitingParse = true;
+      lastPos = i;
+    } else if (awaitingParse && (isSpace(char) || char == COMMA || char == BRACKET_RIGHT) && lastPos > 0) {
+      awaitingParse = false;
+      result.push(deserializeFloat<valueof<T>>(data.slice(lastPos, i)));
+      lastPos = 0;
     }
-    return result;
-  }
+  }
+  return result;
+}

package/assembly/deserialize/array/integer.ts

@@ -5,20 +5,20 @@ import { deserializeInteger } from "../integer";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeIntegerArray<T extends number[]>(data: string): T {
-    const result = instantiate<T>();
-    let lastPos = 0;
-    let i = 1;
-    let awaitingParse = false;
-    for (; i < data.length; i++) {
-        const char = unsafeCharCodeAt(data, i);
-        if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
-            awaitingParse = true;
-            lastPos = i;
-        } else if (awaitingParse && (isSpace(char) || char == COMMA || char == BRACKET_RIGHT) && lastPos > 0) {
-            awaitingParse = false;
-            result.push(deserializeInteger<valueof<T>>(data.slice(lastPos, i)));
-            lastPos = 0;
-        }
+  const result = instantiate<T>();
+  let lastPos = 0;
+  let i = 1;
+  let awaitingParse = false;
+  for (; i < data.length; i++) {
+    const char = unsafeCharCodeAt(data, i);
+    if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
+      awaitingParse = true;
+      lastPos = i;
+    } else if (awaitingParse && (isSpace(char) || char == COMMA || char == BRACKET_RIGHT) && lastPos > 0) {
+      awaitingParse = false;
+      result.push(deserializeInteger<valueof<T>>(data.slice(lastPos, i)));
+      lastPos = 0;
     }
-    return result;
-}
+  }
+  return result;
+}

package/assembly/deserialize/array/map.ts

@@ -4,24 +4,24 @@ import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeMapArray<T extends unknown[]>(data: string): T {
-    const result = instantiate<T>();
-    let lastPos: u32 = 1;
-    let depth: u32 = 0;
-    for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
-        const char = unsafeCharCodeAt(data, pos);
-        if (char === BRACE_LEFT) {
-            if (depth === 0) {
-                lastPos = pos;
-            }
-            depth++;
-        } else if (char === BRACE_RIGHT) {
-            depth--;
-            if (depth === 0) {
-                pos++;
-                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
-                //lastPos = pos + 2;
-            }
-        }
+  const result = instantiate<T>();
+  let lastPos: u32 = 1;
+  let depth: u32 = 0;
+  for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
+    const char = unsafeCharCodeAt(data, pos);
+    if (char === BRACE_LEFT) {
+      if (depth === 0) {
+        lastPos = pos;
+      }
+      depth++;
+    } else if (char === BRACE_RIGHT) {
+      depth--;
+      if (depth === 0) {
+        pos++;
+        result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
+        //lastPos = pos + 2;
+      }
     }
-    return result;
-}
+  }
+  return result;
+}

package/assembly/deserialize/array/object.ts

@@ -4,24 +4,24 @@ import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeObjectArray<T extends unknown[]>(data: string): T {
-    const result = instantiate<T>();
-    let lastPos: u32 = 1;
-    let depth: u32 = 0;
-    for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
-        const char = unsafeCharCodeAt(data, pos);
-        if (char === BRACE_LEFT) {
-            if (depth === 0) {
-                lastPos = pos;
-            }
-            depth++;
-        } else if (char === BRACE_RIGHT) {
-            depth--;
-            if (depth === 0) {
-                pos++;
-                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
-                //lastPos = pos + 2;
-            }
-        }
+  const result = instantiate<T>();
+  let lastPos: u32 = 1;
+  let depth: u32 = 0;
+  for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
+    const char = unsafeCharCodeAt(data, pos);
+    if (char === BRACE_LEFT) {
+      if (depth === 0) {
+        lastPos = pos;
+      }
+      depth++;
+    } else if (char === BRACE_RIGHT) {
+      depth--;
+      if (depth === 0) {
+        pos++;
+        result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
+        //lastPos = pos + 2;
+      }
     }
-    return result;
-}
+  }
+  return result;
+}

package/assembly/deserialize/array/string.ts

@@ -26,4 +26,4 @@ import { deserializeString } from "../string";
     }
   }
   return result;
-}
+}

package/assembly/deserialize/array.ts

@@ -41,6 +41,6 @@ export function deserializeArray<T extends unknown[]>(data: string): T {
 // @ts-ignore: Decorator valid here
 export function deserializeArray_Safe<T extends unknown[]>(data: string): T {
   const firstChar = load<u8>(changetype<usize>(data));
-  if (firstChar != BRACKET_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \"" + data.slice(0, 100) + "\" instead!");
+  if (firstChar != BRACKET_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + ' but got "' + data.slice(0, 100) + '" instead!');
   return deserializeArray<T>(data);
-}
+}

package/assembly/deserialize/bool.ts

@@ -8,13 +8,13 @@ import { unsafeCharCodeAt } from "../custom/util";
  */
 // @ts-ignore: Decorator valid here
 @inline export function deserializeBoolean(data: string, start: i32 = 0, end: i32 = 0): boolean {
-    if (!end) end = data.length;
-    const len = end - start;
-    const ptr = changetype<usize>(data) + <usize>(start << 1);
-    const firstChar = unsafeCharCodeAt(data, start);
-    if (len === 4 && firstChar === CHAR_T && load<u64>(ptr) === 28429475166421108) return true;
-    else if (len === 5 && firstChar === CHAR_F && load<u64>(ptr, 2) === 28429466576093281) return false;
-    return false//ERROR(`Expected to find boolean, but found "${data.slice(0, 100)}" instead!`);
+  if (!end) end = data.length;
+  const len = end - start;
+  const ptr = changetype<usize>(data) + <usize>(start << 1);
+  const firstChar = unsafeCharCodeAt(data, start);
+  if (len === 4 && firstChar === CHAR_T && load<u64>(ptr) === 28429475166421108) return true;
+  else if (len === 5 && firstChar === CHAR_F && load<u64>(ptr, 2) === 28429466576093281) return false;
+  return false; //ERROR(`Expected to find boolean, but found "${data.slice(0, 100)}" instead!`);
 }
 
 /**
@@ -24,11 +24,11 @@ import { unsafeCharCodeAt } from "../custom/util";
  */
 // @ts-ignore: Decorator valid here
 @inline export function deserializeBoolean_Safe(data: string, start: i32 = 0, end: i32 = 0): boolean {
-    if (!end) end = data.length;
-    const len = end - start;
-    const ptr = changetype<usize>(data) + <usize>(start << 1);
-    const firstChar = unsafeCharCodeAt(data, start);
-    if (len === 4 && firstChar === CHAR_T && load<u64>(ptr) === 28429475166421108) return true;
-    else if (len === 5 && firstChar === CHAR_F && load<u64>(ptr, 2) === 28429466576093281) return false;
-    throw new Error("Mismatched Types! Expected boolean but got \"" + data.slice(0, 100) + "\" instead!");
-}
+  if (!end) end = data.length;
+  const len = end - start;
+  const ptr = changetype<usize>(data) + <usize>(start << 1);
+  const firstChar = unsafeCharCodeAt(data, start);
+  if (len === 4 && firstChar === CHAR_T && load<u64>(ptr) === 28429475166421108) return true;
+  else if (len === 5 && firstChar === CHAR_F && load<u64>(ptr, 2) === 28429466576093281) return false;
+  throw new Error('Mismatched Types! Expected boolean but got "' + data.slice(0, 100) + '" instead!');
+}

package/assembly/deserialize/date.ts

@@ -3,10 +3,10 @@ import { QUOTE } from "../custom/chars";
 // @ts-ignore: Decorator valid here
 @inline export function deserializeDate(dateTimeString: string): Date {
   // Use AssemblyScript's date parser
-  const d = Date.fromString(dateTimeString);
+  const d = Date.fromString(dateTimeString.slice(1, -1));
 
   // Return a new object instead of the one that the parser returned.
-  // This may seem redundant, but addreses the issue when Date
+  // This may seem redundant, but addresses the issue when Date
   // is globally aliased to wasi_Date (or some other superclass).
   return new Date(d.getTime());
 }
@@ -14,6 +14,6 @@ import { QUOTE } from "../custom/chars";
 // @ts-ignore: Decorator valid here
 @inline export function deserializeDate_Safe(dateTimeString: string): Date {
   const firstChar = load<u8>(changetype<usize>(dateTimeString));
-  if (firstChar != QUOTE) throw new Error("Mismatched Types! Expected Date but got \"" + dateTimeString.slice(0, 100) + "\" instead!");
+  if (firstChar != QUOTE) throw new Error('Mismatched Types! Expected Date but got "' + dateTimeString.slice(0, 100) + '" instead!');
   return deserializeDate(dateTimeString);
-}
+}

package/assembly/deserialize/float.ts

@@ -1,21 +1,21 @@
 // @ts-ignore: Decorator valid here
 @inline export function deserializeFloat<T>(data: string): T {
-    // @ts-ignore
-    const type: T = 0;
-    // @ts-ignore
-    if (type instanceof f64) return f64.parse(data);
-    // @ts-ignore
-    return f32.parse(data);
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return f64.parse(data);
+  // @ts-ignore
+  return f32.parse(data);
 }
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeFloat_Safe<T>(data: string): T {
-    const firstChar = load<u8>(changetype<usize>(data));
-    if ((firstChar < 48 || firstChar > 57) && firstChar != 45) throw new Error("Mismatched Types! Expected float but got \""+data.slice(0, 100)+"\" instead!");
-    // @ts-ignore
-    const type: T = 0;
-    // @ts-ignore
-    if (type instanceof f64) return f64.parse(data);
-    // @ts-ignore
-    return f32.parse(data);
-}
+  const firstChar = load<u8>(changetype<usize>(data));
+  if ((firstChar < 48 || firstChar > 57) && firstChar != 45) throw new Error('Mismatched Types! Expected float but got "' + data.slice(0, 100) + '" instead!');
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return f64.parse(data);
+  // @ts-ignore
+  return f32.parse(data);
+}

package/assembly/deserialize/integer.ts

@@ -2,15 +2,15 @@ import { snip_fast } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeInteger<T>(data: string): T {
-    // @ts-ignore
-    return snip_fast<T>(data);
+  // @ts-ignore
+  return snip_fast<T>(data);
 }
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeInteger_Safe<T>(data: string): T {
-    const firstChar = load<u8>(changetype<usize>(data));
-    console.log(firstChar.toString())
-    if ((firstChar < 48 || firstChar > 57) && firstChar != 45) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \""+data.slice(0, 100)+"\" instead!");
-    // @ts-ignore
-    return snip_fast<T>(data);
-}
+  const firstChar = load<u8>(changetype<usize>(data));
+  console.log(firstChar.toString());
+  if ((firstChar < 48 || firstChar > 57) && firstChar != 45) throw new Error("Mismatched Types! Expected " + nameof<T>() + ' but got "' + data.slice(0, 100) + '" instead!');
+  // @ts-ignore
+  return snip_fast<T>(data);
+}