json-as 0.9.1 → 0.9.3

package/CHANGELOG

@@ -4,6 +4,8 @@ v0.8.4 - Fix #71. Classes with the extending class overriding a property cause t
 v0.8.5 - Fix #73. Support for nullable primatives with Box<T> from as-container
 v0.8.6 - Fix. Forgot to stash before publishing. Stash and push what should have been v0.8.5
 
-v0.9.0 - Large update. Refactor all the code, nullable primitives, rewrite the transform, allow extensibility with @omit keywords, and fix a plethora of bugs
+v0.9.0 - BREAKING CHANGE - API changed from JSON.parse(data, defaultValues) to JSON.parse(data). Default Values defaults to true. Large update. Refactor all the code, nullable primitives, rewrite the transform, allow extensibility with @omit keywords, and fix a plethora of bugs
 v0.9.1 - Fix #71
+v0.9.2 - Fix #75 + Build sizes significantly reduced
+
 [UNRELEASED] v0.9.x - Port JSON.Value from the `develop` branch to allow for union types, parsing of arbitrary data, and whatever the hell you want.

package/README.md

@@ -7,7 +7,7 @@
 ██║  ██║███████║      ╚█████╔╝███████║╚██████╔╝██║ ╚████║
 ╚═╝  ╚═╝╚══════╝       ╚════╝ ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝
 
-v0.9.1
+v0.9.3
 </pre>
 </h3>
 

package/assembly/__tests__/deserialize.spec.ts

@@ -240,7 +240,7 @@ describe("Should deserialize object arrays", () => {
 
 });
 
-describe("Ser/de Objects", () => {
+describe("Should deserialize Objects", () => {
 
   expect(
     JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}'))

package/assembly/__tests__/serialize.spec.ts

@@ -48,6 +48,16 @@ class Player {
   isVerified: boolean;
 }
 
+@json
+class OmitIf {
+  x: i32 = 1;
+  @omitif("this.y == -1")
+  y: i32 = -1;
+  z: i32 = 1;
+  @omitnull()
+  foo: string | null = null
+}
+
 class Nullable { }
 type Null = Nullable | null;
 
@@ -297,7 +307,7 @@ describe("Should serialize object arrays", () => {
 
 });
 
-describe("Ser/de Objects", () => {
+describe("Should serialize objects", () => {
 
   expect(
     JSON.stringify<Vec3>({
@@ -348,6 +358,16 @@ describe("Ser/de Objects", () => {
 
 });
 
+describe("Should serialize @omit'ed objects", () => {
+
+  expect(
+    JSON.stringify(<OmitIf>{
+      y: 1
+    })
+  ).toBe('{"x":1,"y":1,"z":1}');
+
+});
+
 @json
 class ObjWithString {
   s!: string;

package/assembly/deserialize/array/array.ts

@@ -1,9 +1,9 @@
-import { leftBracketCode, rightBracketCode } from "../../src/chars";
+import { BRACKET_LEFT, BRACKET_RIGHT } from "../../src/chars";
 import { JSON } from "../..";
 import { unsafeCharCodeAt } from "../../src/util";
 
 // @ts-ignore: Decorator
-@inline export function deserializeArrayArray<T extends unknown[][]>(data: string): T {
+export function deserializeArrayArray<T extends unknown[][]>(data: string): T {
     const result = instantiate<T>();
     let lastPos = 0;
     let depth = 0;
@@ -13,13 +13,13 @@ import { unsafeCharCodeAt } from "../../src/util";
     //i++;
     for (; i < data.length - 1; i++) {
         const char = unsafeCharCodeAt(data, i);
-        if (char === leftBracketCode) {
+        if (char === BRACKET_LEFT) {
             if (depth === 0) {
                 lastPos = i;
             }
             // Shifting is 6% faster than incrementing
             depth++;
-        } else if (char === rightBracketCode) {
+        } else if (char === BRACKET_RIGHT) {
             depth--;
             if (depth === 0) {
                 i++;

package/assembly/deserialize/array/bool.ts

@@ -1,16 +1,16 @@
-import { eCode, fCode, tCode } from "../../src/chars";
+import { CHAR_E, CHAR_F, CHAR_T } from "../../src/chars";
 import { unsafeCharCodeAt } from "../../src/util";
 import { deserializeBoolean } from "../bool";
 
 // @ts-ignore: Decorator
-@inline export function deserializeBooleanArray<T extends boolean[]>(data: string): T {
+export function deserializeBooleanArray<T extends boolean[]>(data: string): T {
   const result = instantiate<T>();
   let lastPos = 1;
   for (let i = 1; i < data.length - 1; i++) {
     const char = unsafeCharCodeAt(data, i);
-    if (char === tCode || char === fCode) {
+    if (char === CHAR_T || char === CHAR_F) {
       lastPos = i;
-    } else if (char === eCode) {
+    } else if (char === CHAR_E) {
       i++;
       result.push(deserializeBoolean(data.slice(lastPos, i)));
     }

package/assembly/deserialize/array/float.ts

@@ -1,10 +1,10 @@
 import { isSpace } from "util/string";
 import { unsafeCharCodeAt } from "../../src/util";
-import { commaCode, rightBracketCode } from "../../src/chars";
+import { COMMA, BRACKET_RIGHT } from "../../src/chars";
 import { deserializeFloat } from "../float";
 
 // @ts-ignore: Decorator
-@inline export function deserializeFloatArray<T extends number[]>(data: string): T {
+export function deserializeFloatArray<T extends number[]>(data: string): T {
     const result = instantiate<T>();
     let lastPos = 0;
     let i = 1;
@@ -14,7 +14,7 @@ import { deserializeFloat } from "../float";
       if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
         awaitingParse = true;
         lastPos = i;
-      } else if (awaitingParse && (isSpace(char) || char == commaCode || char == rightBracketCode) && lastPos > 0) {
+      } 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;

package/assembly/deserialize/array/integer.ts

@@ -1,10 +1,10 @@
 import { isSpace } from "util/string";
 import { unsafeCharCodeAt } from "../../src/util";
-import { commaCode, rightBracketCode } from "../../src/chars";
+import { COMMA, BRACKET_RIGHT } from "../../src/chars";
 import { deserializeInteger } from "../integer";
 
 // @ts-ignore: Decorator
-@inline export function deserializeIntegerArray<T extends number[]>(data: string): T {
+export function deserializeIntegerArray<T extends number[]>(data: string): T {
     const result = instantiate<T>();
     let lastPos = 0;
     let i = 1;
@@ -14,7 +14,7 @@ import { deserializeInteger } from "../integer";
         if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
             awaitingParse = true;
             lastPos = i;
-        } else if (awaitingParse && (isSpace(char) || char == commaCode || char == rightBracketCode) && lastPos > 0) {
+        } 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;

package/assembly/deserialize/array/map.ts

@@ -1,20 +1,20 @@
-import { leftBraceCode, rightBraceCode } from "../../src/chars";
+import { BRACE_LEFT, BRACE_RIGHT } from "../../src/chars";
 import { JSON } from "../..";
 import { unsafeCharCodeAt } from "../../src/util";
 
 // @ts-ignore: Decorator
-@inline export function deserializeMapArray<T extends unknown[]>(data: string): T {
+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 === leftBraceCode) {
+        if (char === BRACE_LEFT) {
             if (depth === 0) {
                 lastPos = pos;
             }
             depth++;
-        } else if (char === rightBraceCode) {
+        } else if (char === BRACE_RIGHT) {
             depth--;
             if (depth === 0) {
                 pos++;

package/assembly/deserialize/array/object.ts

@@ -1,20 +1,20 @@
-import { leftBraceCode, rightBraceCode } from "../../src/chars";
+import { BRACE_LEFT, BRACE_RIGHT } from "../../src/chars";
 import { JSON } from "../..";
 import { unsafeCharCodeAt } from "../../src/util";
 
 // @ts-ignore: Decorator
-@inline export function deserializeObjectArray<T extends unknown[]>(data: string): T {
+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 === leftBraceCode) {
+        if (char === BRACE_LEFT) {
             if (depth === 0) {
                 lastPos = pos;
             }
             depth++;
-        } else if (char === rightBraceCode) {
+        } else if (char === BRACE_RIGHT) {
             depth--;
             if (depth === 0) {
                 pos++;

package/assembly/deserialize/array/string.ts

@@ -1,19 +1,19 @@
-import { backSlashCode, quoteCode } from "../../src/chars";
+import { BACK_SLASH, QUOTE } from "../../src/chars";
 import { unsafeCharCodeAt } from "../../src/util";
 import { deserializeString } from "../string";
 
 // @ts-ignore: Decorator
-@inline export function deserializeStringArray(data: string): string[] {
+export function deserializeStringArray(data: string): string[] {
   const result: string[] = [];
   let lastPos = 0;
   let instr = false;
   let escaping = false;
   for (let i = 1; i < data.length - 1; i++) {
     const char = unsafeCharCodeAt(data, i);
-    if (char === backSlashCode && !escaping) {
+    if (char === BACK_SLASH && !escaping) {
       escaping = true;
     } else {
-      if (char === quoteCode && !escaping) {
+      if (char === QUOTE && !escaping) {
         if (instr === false) {
           instr = true;
           lastPos = i;

package/assembly/deserialize/array.ts

@@ -8,7 +8,7 @@ import { deserializeObjectArray } from "./array/object";
 import { deserializeStringArray } from "./array/string";
 
 // @ts-ignore: Decorator
-@inline export function deserializeArray<T extends unknown[]>(data: string): T {
+export function deserializeArray<T extends unknown[]>(data: string): T {
     if (isString<valueof<T>>()) {
         return <T>deserializeStringArray(data);
     } else if (isBoolean<valueof<T>>()) {

package/assembly/deserialize/bool.ts

@@ -1,4 +1,4 @@
-import { fCode, tCode } from "../src/chars";
+import { CHAR_F, CHAR_T } from "../src/chars";
 import { unsafeCharCodeAt } from "../src/util";
 
 /**
@@ -7,12 +7,12 @@ import { unsafeCharCodeAt } from "../src/util";
  * @returns boolean
  */
 // @ts-ignore: Decorator
-@inline export function deserializeBoolean(data: string, start: i32 = 0, end: i32 = 0): boolean {
+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 === tCode && load<u64>(ptr) === 28429475166421108) return true;
-    else if (len === 5 && firstChar === fCode && load<u64>(ptr, 2) === 28429466576093281) return false;
+    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!`);
 }

package/assembly/deserialize/box.ts

@@ -1,7 +1,7 @@
 import { JSON } from "..";
 
 // @ts-ignore: Decorator
-@inline export function deserializeBox<T extends Box<any>>(data: string): T {
+export function deserializeBox<T extends Box<any>>(data: string): T {
     if (isNullable<T>() && data == "null") {
         return null;
     }
@@ -12,6 +12,6 @@ import { JSON } from "..";
     return changetype<T>(instance);
 }
 
-@inline function parseDirectInference<T>(type: T, data: string, initializeDefaultValues: boolean = false): T {
+function parseDirectInference<T>(type: T, data: string, initializeDefaultValues: boolean = false): T {
     return JSON.parse<T>(data, initializeDefaultValues)
 }

package/assembly/deserialize/date.ts

@@ -1,5 +1,5 @@
 // @ts-ignore
-@inline export function deserializeDate(dateTimeString: string): Date {
+export function deserializeDate(dateTimeString: string): Date {
     // Use AssemblyScript's date parser
     const d = Date.fromString(dateTimeString);
   

package/assembly/deserialize/float.ts

@@ -1,5 +1,5 @@
 // @ts-ignore: Decorator
-@inline export function deserializeFloat<T>(data: string): T {
+export function deserializeFloat<T>(data: string): T {
     // @ts-ignore
     const type: T = 0;
     // @ts-ignore

package/assembly/deserialize/integer.ts

@@ -1,7 +1,7 @@
 import { snip_fast } from "../src/util";
 
 // @ts-ignore: Decorator
-@inline export function deserializeInteger<T>(data: string): T {
+export function deserializeInteger<T>(data: string): T {
     // @ts-ignore
     return snip_fast<T>(data);
 }

package/assembly/deserialize/map.ts

@@ -1,23 +1,23 @@
 import { Virtual } from "as-virtual/assembly";
 import { containsCodePoint, unsafeCharCodeAt } from "../src/util";
 import {
-    aCode,
-    backSlashCode,
-    colonCode,
-    commaCode,
-    eCode,
-    fCode,
-    lCode,
-    leftBraceCode,
-    leftBracketCode,
-    nCode,
-    quoteCode,
-    rCode,
-    rightBraceCode,
-    rightBracketCode,
-    sCode,
-    tCode,
-    uCode
+    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 "../src/chars";
 import { deserializeBoolean } from "./bool";
 import { JSON } from "..";
@@ -27,7 +27,7 @@ import { deserializeInteger } from "./integer";
 import { deserializeFloat } from "./float";
 
 // @ts-ignore: Decorator
-@inline export function deserializeMap<T extends Map>(data: string): T {
+export function deserializeMap<T extends Map>(data: string): T {
 
     const map: nonnull<T> = changetype<nonnull<T>>(
         __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
@@ -39,16 +39,16 @@ import { deserializeFloat } from "./float";
     let outerLoopIndex = 1;
     for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
         const char = unsafeCharCodeAt(data, outerLoopIndex);
-        if (char === leftBracketCode) {
+        if (char === BRACKET_LEFT) {
             for (
                 let arrayValueIndex = outerLoopIndex;
                 arrayValueIndex < data.length - 1;
                 arrayValueIndex++
             ) {
                 const char = unsafeCharCodeAt(data, arrayValueIndex);
-                if (char === leftBracketCode) {
+                if (char === BRACKET_LEFT) {
                     depth++;
-                } else if (char === rightBracketCode) {
+                } else if (char === BRACKET_RIGHT) {
                     depth--;
                     if (depth === 0) {
                         ++arrayValueIndex;
@@ -59,16 +59,16 @@ import { deserializeFloat } from "./float";
                     }
                 }
             }
-        } else if (char === leftBraceCode) {
+        } else if (char === BRACE_LEFT) {
             for (
                 let objectValueIndex = outerLoopIndex;
                 objectValueIndex < data.length - 1;
                 objectValueIndex++
             ) {
                 const char = unsafeCharCodeAt(data, objectValueIndex);
-                if (char === leftBraceCode) {
+                if (char === BRACE_LEFT) {
                     depth++;
-                } else if (char === rightBraceCode) {
+                } else if (char === BRACE_RIGHT) {
                     depth--;
                     if (depth === 0) {
                         ++objectValueIndex;
@@ -79,7 +79,7 @@ import { deserializeFloat } from "./float";
                     }
                 }
             }
-        } else if (char === quoteCode) {
+        } else if (char === QUOTE) {
             let escaping = false;
             for (
                 let stringValueIndex = ++outerLoopIndex;
@@ -87,15 +87,15 @@ import { deserializeFloat } from "./float";
                 stringValueIndex++
             ) {
                 const char = unsafeCharCodeAt(data, stringValueIndex);
-                if (char === backSlashCode && !escaping) {
+                if (char === BACK_SLASH && !escaping) {
                     escaping = true;
                 } else {
                     if (
-                        char === quoteCode && !escaping
+                        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, backSlashCode, outerLoopIndex, stringValueIndex)) {
+                            if (containsCodePoint(data, BACK_SLASH, outerLoopIndex, stringValueIndex)) {
                                 key.reinst(deserializeString(data, outerLoopIndex - 1, stringValueIndex));
                             } else {
                                 key.reinst(data, outerLoopIndex, stringValueIndex);
@@ -115,30 +115,30 @@ import { deserializeFloat } from "./float";
                 }
             }
         } else if (
-            char == nCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode) {
+            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 === tCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+            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 === fCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === aCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === sCode &&
-            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+            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);
@@ -148,7 +148,7 @@ import { deserializeFloat } from "./float";
             let numberValueIndex = ++outerLoopIndex;
             for (; numberValueIndex < data.length; numberValueIndex++) {
                 const char = unsafeCharCodeAt(data, numberValueIndex);
-                if (char === colonCode || char === commaCode || char === rightBraceCode || isSpace(char)) {
+                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>>()) {
@@ -166,7 +166,7 @@ import { deserializeFloat } from "./float";
 }
 
 //@ts-ignore: Decorator
-@inline function deserializeMapKey<T>(key: Virtual<string>): T {
+function deserializeMapKey<T>(key: Virtual<string>): T {
     const k = key.copyOut();
     if (isString<T>()) {
         return k as T;

package/assembly/deserialize/object.ts

@@ -1,9 +1,9 @@
 import { containsCodePoint, unsafeCharCodeAt } from "../src/util";
-import { aCode, backSlashCode, commaCode, eCode, fCode, lCode, leftBraceCode, leftBracketCode, nCode, quoteCode, rCode, rightBraceCode, rightBracketCode, sCode, tCode, uCode } from "../src/chars";
+import { CHAR_A, BACK_SLASH, 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 "../src/chars";
 import { isSpace } from "util/string";
 
 // @ts-ignore: Decorator
-@inline export function deserializeObject<T>(data: string): T {
+export function deserializeObject<T>(data: string): T {
   const schema: nonnull<T> = changetype<nonnull<T>>(
     __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
   );
@@ -18,16 +18,16 @@ import { isSpace } from "util/string";
   let outerLoopIndex = 1;
   for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
     const char = unsafeCharCodeAt(data, outerLoopIndex);
-    if (char === leftBracketCode) {
+    if (char === BRACKET_LEFT) {
       for (
         let arrayValueIndex = outerLoopIndex;
         arrayValueIndex < data.length - 1;
         arrayValueIndex++
       ) {
         const char = unsafeCharCodeAt(data, arrayValueIndex);
-        if (char === leftBracketCode) {
+        if (char === BRACKET_LEFT) {
           depth++;
-        } else if (char === rightBracketCode) {
+        } else if (char === BRACKET_RIGHT) {
           depth--;
           if (depth === 0) {
             ++arrayValueIndex;
@@ -39,16 +39,16 @@ import { isSpace } from "util/string";
           }
         }
       }
-    } else if (char === leftBraceCode) {
+    } else if (char === BRACE_LEFT) {
       for (
         let objectValueIndex = outerLoopIndex;
         objectValueIndex < data.length - 1;
         objectValueIndex++
       ) {
         const char = unsafeCharCodeAt(data, objectValueIndex);
-        if (char === leftBraceCode) {
+        if (char === BRACE_LEFT) {
           depth++;
-        } else if (char === rightBraceCode) {
+        } else if (char === BRACE_RIGHT) {
           depth--;
           if (depth === 0) {
             ++objectValueIndex;
@@ -60,7 +60,7 @@ import { isSpace } from "util/string";
           }
         }
       }
-    } else if (char === quoteCode) {
+    } else if (char === QUOTE) {
       let escaping = false;
       for (
         let stringValueIndex = ++outerLoopIndex;
@@ -68,10 +68,10 @@ import { isSpace } from "util/string";
         stringValueIndex++
       ) {
         const char = unsafeCharCodeAt(data, stringValueIndex);
-        if (char === backSlashCode && !escaping) {
+        if (char === BACK_SLASH && !escaping) {
           escaping = true;
         } else {
-          if (char === quoteCode && !escaping) {
+          if (char === QUOTE && !escaping) {
             if (isKey === false) {
               key_start = outerLoopIndex;
               key_end = stringValueIndex;
@@ -88,31 +88,31 @@ import { isSpace } from "util/string";
         }
       }
     } else if (
-      char == nCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === uCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === lCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === lCode
+      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 === tCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === rCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === uCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === eCode
+      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 === fCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === aCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === lCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === sCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 4) === eCode
+      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);
@@ -122,7 +122,7 @@ import { isSpace } from "util/string";
       let numberValueIndex = ++outerLoopIndex;
       for (; numberValueIndex < data.length; numberValueIndex++) {
         const char = unsafeCharCodeAt(data, numberValueIndex);
-        if (char === commaCode || char === rightBraceCode || isSpace(char)) {
+        if (char === COMMA || char === BRACE_RIGHT || isSpace(char)) {
           // @ts-ignore
           schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex - 1, numberValueIndex);
           outerLoopIndex = numberValueIndex;