json-as 0.8.6 → 0.8.8

package/CHANGELOG

@@ -2,4 +2,5 @@ v0.8.2 - Properties starting with `static` or `private` would be ignored
 v0.8.3 - Dirty fix to issue #68. Add __JSON_Stringify callable to global scope.
 v0.8.4 - Fix #71. Classes with the extending class overriding a property cause the property to be serialized twice.
 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.8.6 - Fix. Forgot to stash before publishing. Stash and push what should have been v0.8.5
+v0.8.8 - Depreacte v0.8.7, roll 0.8.6 -> 0.8.8

package/assembly/__benches__/as-json.ts

@@ -30,7 +30,7 @@ bench("Parse Number OLD", () => {
 });
 
 bench("Stringify Object (Vec3)", () => {
-  blackbox<string>(vec.__JSON_Serialize());
+  blackbox<string>(vec.__SERIALIZE());
 });*/
 
 // TODO: Make this allocate without crashing

package/assembly/deserialize/array/array.ts

@@ -0,0 +1,31 @@
+import { leftBracketCode, rightBracketCode } from "../../src/chars";
+import { JSON } from "../../src/json";
+import { unsafeCharCodeAt } from "../../src/util";
+
+// @ts-ignore: Decorator
+@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 === leftBracketCode) {
+            if (depth === 0) {
+                lastPos = i;
+            }
+            // Shifting is 6% faster than incrementing
+            depth++;
+        } else if (char === rightBracketCode) {
+            depth--;
+            if (depth === 0) {
+                i++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+            }
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/bool.ts

@@ -0,0 +1,19 @@
+import { eCode, fCode, tCode } 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 {
+  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) {
+      lastPos = i;
+    } else if (char === eCode) {
+      i++;
+      result.push(deserializeBoolean(data.slice(lastPos, i)));
+    }
+  }
+  return result;
+}

package/assembly/deserialize/array/float.ts

@@ -0,0 +1,24 @@
+import { isSpace } from "util/string";
+import { unsafeCharCodeAt } from "../../src/util";
+import { commaCode, rightBracketCode } from "../../src/chars";
+import { deserializeFloat } from "../float";
+
+// @ts-ignore: Decorator
+@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 == commaCode || char == rightBracketCode) && lastPos > 0) {
+        awaitingParse = false;
+        result.push(deserializeFloat<valueof<T>>(data.slice(lastPos, i)));
+        lastPos = 0;
+      }
+    }
+    return result;
+  }

package/assembly/deserialize/array/integer.ts

@@ -0,0 +1,24 @@
+import { isSpace } from "util/string";
+import { unsafeCharCodeAt } from "../../src/util";
+import { commaCode, rightBracketCode } from "../../src/chars";
+import { deserializeInteger } from "../integer";
+
+// @ts-ignore: Decorator
+@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 == commaCode || char == rightBracketCode) && lastPos > 0) {
+            awaitingParse = false;
+            result.push(deserializeInteger<valueof<T>>(data.slice(lastPos, i)));
+            lastPos = 0;
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/map.ts

@@ -0,0 +1,27 @@
+import { leftBraceCode, rightBraceCode } from "../../src/chars";
+import { JSON } from "../../src/json";
+import { unsafeCharCodeAt } from "../../src/util";
+
+// @ts-ignore: Decorator
+@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 === leftBraceCode) {
+            if (depth === 0) {
+                lastPos = pos;
+            }
+            depth++;
+        } else if (char === rightBraceCode) {
+            depth--;
+            if (depth === 0) {
+                pos++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
+                //lastPos = pos + 2;
+            }
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/object.ts

@@ -0,0 +1,27 @@
+import { leftBraceCode, rightBraceCode } from "../../src/chars";
+import { JSON } from "../../src/json";
+import { unsafeCharCodeAt } from "../../src/util";
+
+// @ts-ignore: Decorator
+@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 === leftBraceCode) {
+            if (depth === 0) {
+                lastPos = pos;
+            }
+            depth++;
+        } else if (char === rightBraceCode) {
+            depth--;
+            if (depth === 0) {
+                pos++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
+                //lastPos = pos + 2;
+            }
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/string.ts

@@ -0,0 +1,29 @@
+import { backSlashCode, quoteCode } from "../../src/chars";
+import { unsafeCharCodeAt } from "../../src/util";
+import { deserializeString } from "../string";
+
+// @ts-ignore: Decorator
+@inline 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) {
+      escaping = true;
+    } else {
+      if (char === quoteCode && !escaping) {
+        if (instr === false) {
+          instr = true;
+          lastPos = i;
+        } else {
+          instr = false;
+          result.push(deserializeString(data, lastPos, i));
+        }
+      }
+      escaping = false;
+    }
+  }
+  return result;
+}

package/assembly/deserialize/array.ts

@@ -0,0 +1,37 @@
+import { isMap } from "../src/util";
+import { deserializeArrayArray } from "./array/array";
+import { deserializeBooleanArray } from "./array/bool";
+import { deserializeFloatArray } from "./array/float";
+import { deserializeIntegerArray } from "./array/integer";
+import { deserializeMapArray } from "./array/map";
+import { deserializeObjectArray } from "./array/object";
+import { deserializeStringArray } from "./array/string";
+
+// @ts-ignore: Decorator
+@inline export function deserializeArray<T extends unknown[]>(data: string): T {
+    if (isString<valueof<T>>()) {
+        return <T>deserializeStringArray(data);
+    } else if (isBoolean<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeBooleanArray<T>(data);
+    } else if (isInteger<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeIntegerArray<T>(data);
+    } else if (isFloat<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeFloatArray<T>(data);
+    } else if (isArrayLike<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeArrayArray<T>(data);
+    } else if (isMap<valueof<T>>()) {
+        return deserializeMapArray<T>(data);
+    } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+        const type = changetype<nonnull<valueof<T>>>(0);
+        // @ts-ignore
+        if (isDefined(type.__JSON_Set_Key)) {
+            return deserializeObjectArray<T>(data);
+        }
+    }
+
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+}

package/assembly/deserialize/bool.ts

@@ -0,0 +1,18 @@
+import { fCode, tCode } from "../src/chars";
+import { unsafeCharCodeAt } from "../src/util";
+
+/**
+ * Deserialize a string to type boolean
+ * @param data data to parse
+ * @returns boolean
+ */
+// @ts-ignore: Decorator
+@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 === tCode && load<u64>(ptr) === 28429475166421108) return true;
+    else if (len === 5 && firstChar === fCode && 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

@@ -0,0 +1,14 @@
+import { JSON } from "../src/json";
+
+// @ts-ignore: Decorator
+@inline export function deserializeBox<T extends Box<any>>(data: string): T {
+    const instance = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()))// as Box<usize>;
+    const val = instance._val;
+    instance._val = parseDirectInference(val, data);
+    // @ts-ignore
+    return changetype<T>(instance);
+}
+
+@inline function parseDirectInference<T>(type: T, data: string, initializeDefaultValues: boolean = false): T {
+    return JSON.parse<T>(data, initializeDefaultValues)
+}

package/assembly/deserialize/date.ts

@@ -0,0 +1,11 @@
+// @ts-ignore
+@inline export function deserializeDate(dateTimeString: string): Date {
+    // Use AssemblyScript's date parser
+    const d = Date.fromString(dateTimeString);
+  
+    // Return a new object instead of the one that the parser returned.
+    // This may seem redundant, but addreses the issue when Date
+    // is globally aliased to wasi_Date (or some other superclass).
+    return new Date(d.getTime());
+  }
+  

package/assembly/deserialize/float.ts

@@ -0,0 +1,9 @@
+// @ts-ignore: Decorator
+@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);
+}

package/assembly/deserialize/integer.ts

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

package/assembly/deserialize/map.ts

@@ -0,0 +1,182 @@
+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
+} from "../src/chars";
+import { deserializeBoolean } from "./bool";
+import { JSON } from "../src/json";
+import { deserializeString } from "./string";
+import { isSpace } from "util/string";
+import { deserializeInteger } from "./integer";
+import { deserializeFloat } from "./float";
+
+// @ts-ignore: Decorator
+@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 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 === leftBracketCode) {
+            for (
+                let arrayValueIndex = outerLoopIndex;
+                arrayValueIndex < data.length - 1;
+                arrayValueIndex++
+            ) {
+                const char = unsafeCharCodeAt(data, arrayValueIndex);
+                if (char === leftBracketCode) {
+                    depth++;
+                } else if (char === rightBracketCode) {
+                    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 === leftBraceCode) {
+            for (
+                let objectValueIndex = outerLoopIndex;
+                objectValueIndex < data.length - 1;
+                objectValueIndex++
+            ) {
+                const char = unsafeCharCodeAt(data, objectValueIndex);
+                if (char === leftBraceCode) {
+                    depth++;
+                } else if (char === rightBraceCode) {
+                    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 === quoteCode) {
+            let escaping = false;
+            for (
+                let stringValueIndex = ++outerLoopIndex;
+                stringValueIndex < data.length - 1;
+                stringValueIndex++
+            ) {
+                const char = unsafeCharCodeAt(data, stringValueIndex);
+                if (char === backSlashCode && !escaping) {
+                    escaping = true;
+                } else {
+                    if (
+                        char === quoteCode && !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)) {
+                                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 == nCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode) {
+            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
+        ) {
+            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
+        ) {
+            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 === colonCode || char === commaCode || char === rightBraceCode || 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;
+}
+
+//@ts-ignore: Decorator
+@inline 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);
+    }
+
+    throw new Error(`JSON: Cannot parse JSON object to a Map with a key of type ${nameof<T>()}`);
+}

package/assembly/deserialize/object.ts

@@ -0,0 +1,139 @@
+import { Virtual } from "as-virtual/assembly";
+import { containsCodePoint, unsafeCharCodeAt } from "../src/util";
+import { nullWord,trueWord,falseWord,aCode, backSlashCode, commaCode, eCode, fCode, lCode, leftBraceCode, leftBracketCode, nCode, quoteCode, rCode, rightBraceCode, rightBracketCode, sCode, tCode, uCode } from "../src/chars";
+import { deserializeString } from "./string";
+import { isSpace } from "util/string";
+
+// @ts-ignore: Decorator
+@inline export function deserializeObject<T>(data: string, initializeDefaultValues: boolean): T {
+    const schema: nonnull<T> = changetype<nonnull<T>>(
+      __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
+    );
+  
+    // @ts-ignore
+    if (initializeDefaultValues) schema.__JSON_Initialize();
+  
+    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 === leftBracketCode) {
+        for (
+          let arrayValueIndex = outerLoopIndex;
+          arrayValueIndex < data.length - 1;
+          arrayValueIndex++
+        ) {
+          const char = unsafeCharCodeAt(data, arrayValueIndex);
+          if (char === leftBracketCode) {
+            depth++;
+          } else if (char === rightBracketCode) {
+            depth--;
+            if (depth === 0) {
+              ++arrayValueIndex;
+              // @ts-ignore
+              schema.__JSON_Set_Key(key, data, outerLoopIndex, arrayValueIndex, initializeDefaultValues);
+              outerLoopIndex = arrayValueIndex;
+              isKey = false;
+              break;
+            }
+          }
+        }
+      } else if (char === leftBraceCode) {
+        for (
+          let objectValueIndex = outerLoopIndex;
+          objectValueIndex < data.length - 1;
+          objectValueIndex++
+        ) {
+          const char = unsafeCharCodeAt(data, objectValueIndex);
+          if (char === leftBraceCode) {
+            depth++;
+          } else if (char === rightBraceCode) {
+            depth--;
+            if (depth === 0) {
+              ++objectValueIndex;
+              // @ts-ignore
+              schema.__JSON_Set_Key(key, data, outerLoopIndex, objectValueIndex, initializeDefaultValues);
+              outerLoopIndex = objectValueIndex;
+              isKey = false;
+              break;
+            }
+          }
+        }
+      } else if (char === quoteCode) {
+        let escaping = false;
+        for (
+          let stringValueIndex = ++outerLoopIndex;
+          stringValueIndex < data.length - 1;
+          stringValueIndex++
+        ) {
+          const char = unsafeCharCodeAt(data, stringValueIndex);
+          if (char === backSlashCode && !escaping) {
+            escaping = true;
+          } else {
+            if (char === quoteCode && !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)) {
+                  key.reinst(deserializeString(data, outerLoopIndex - 1, stringValueIndex));
+                } else {
+                  key.reinst(data, outerLoopIndex, stringValueIndex);
+                }
+                isKey = true;
+              } else {
+                const value = deserializeString(data, outerLoopIndex - 1, stringValueIndex);
+                // @ts-ignore
+                schema.__JSON_Set_Key(key, value, 0, value.length, initializeDefaultValues);
+                isKey = false;
+              }
+              outerLoopIndex = ++stringValueIndex;
+              break;
+            }
+            escaping = false;
+          }
+        }
+      } else if (
+        char == nCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === lCode
+      ) {
+        // @ts-ignore
+        schema.__JSON_Set_Key(key, nullWord, 0, 4, initializeDefaultValues);
+        isKey = false;
+      } else if (
+        char === tCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+      ) {
+        // @ts-ignore
+        schema.__JSON_Set_Key(key, trueWord, 0, 4, initializeDefaultValues);
+        isKey = false;
+      } else if (
+        char === fCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === aCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === sCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+      ) {
+        // @ts-ignore
+        schema.__JSON_Set_Key(key, falseWord, 0, 5, initializeDefaultValues);
+        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 === commaCode || char === rightBraceCode || isSpace(char)) {
+            // @ts-ignore
+            schema.__JSON_Set_Key(key, data, outerLoopIndex - 1, numberValueIndex, initializeDefaultValues);
+            outerLoopIndex = numberValueIndex;
+            isKey = false;
+            break;
+          }
+        }
+      }
+    }
+    return schema;
+  }