json-as 1.1.14-preview.1 → 1.1.14

package/CHANGELOG.md

@@ -1,11 +1,5 @@
 # Change Log
 
-## UNRELEASED
-
-- feat: support `JSON.Raw` in array types
-- tests: add tests for `JSON.Raw[]`
-- tests: properly support nulls (in testing lib)
-
 ## 2025-05-29 - 1.1.14
 
 - fix: hotfix schema resolver

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.1.14-preview.1
+    AssemblyScript - v1.1.14
   </pre>
 </h6>
 
@@ -23,7 +23,6 @@ JSON is the de-facto serialization format of modern web applications, but its se
   - [Nullable Primitives](#️-using-nullable-primitives)
   - [Unknown or Dynamic Data](#-working-with-unknown-or-dynamic-data)
   - [Using Raw JSON Strings](#️-using-raw-json-strings)
-  - [Using Enums](#️-working-with-enums)
   - [Custom Serializers](#️-using-custom-serializers-or-deserializers)
 - [Performance](#-performance)
 - [Debugging](#-debugging)
@@ -303,23 +302,6 @@ console.log(JSON.stringify(map));
 // Now its properly formatted JSON where pos's value is of type Vec3 not string!
 ```
 
-### 📝 Working with enums
-
-By default, enums arn't supported by `json-as`. However, you can use a workaround:
-
-```typescript
-namespace Foo {
-  export const bar = "a";
-  export const baz = "b";
-  export const gob = "c";
-}
-
-type Foo = string;
-
-const serialized = JSON.stringify<Foo>(Foo.bar);
-// "a"
-```
-
 ### ⚒️ Using custom serializers or deserializers
 
 This library supports custom serialization and deserialization methods, which can be defined using the `@serializer` and `@deserializer` decorators.

package/assembly/__tests__/array.spec.ts

@@ -1,144 +1,174 @@
 import { JSON } from "..";
 import { describe, expect } from "./lib";
 
-describe("Should serialize integer arrays", () => {
-  expect(JSON.stringify<u32[]>([0, 100, 101])).toBe("[0,100,101]");
-
-  expect(JSON.stringify<u64[]>([0, 100, 101])).toBe("[0,100,101]");
-
-  expect(JSON.stringify<i32[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
-
-  expect(JSON.stringify<i64[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
-});
-
-describe("Should serialize float arrays", () => {
-  expect(JSON.stringify<f64[]>([7.23, 10e2, 10e2, 123456e-5, 123456e-5, 0.0, 7.23])).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
-
-  expect(JSON.stringify<f64[]>([1e21, 1e22, 1e-7, 1e-8, 1e-9])).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
-});
-
-describe("Should serialize boolean arrays", () => {
-  expect(JSON.stringify<bool[]>([true, false])).toBe("[true,false]");
-
-  expect(JSON.stringify<boolean[]>([true, false])).toBe("[true,false]");
-});
-
-describe("Should serialize string arrays", () => {
-  expect(JSON.stringify<string[]>(['string "with random spa\nces and \nnewlines\n\n\n'])).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
-});
-
-describe("Should serialize nested integer arrays", () => {
-  expect(JSON.stringify<i64[][]>([[100, 101], [-100, -101], [0]])).toBe("[[100,101],[-100,-101],[0]]");
-});
-
-describe("Should serialize nested float arrays", () => {
-  expect(JSON.stringify<f64[][]>([[7.23], [10e2], [10e2], [123456e-5], [123456e-5], [0.0], [7.23]])).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
-});
-
-describe("Should serialize nested boolean arrays", () => {
-  expect(JSON.stringify<bool[][]>([[true], [false]])).toBe("[[true],[false]]");
-
-  expect(JSON.stringify<boolean[][]>([[true], [false]])).toBe("[[true],[false]]");
-});
-
-describe("Should serialize object arrays", () => {
-  expect(
-    JSON.stringify<Vec3[]>([
-      {
-        x: 3.4,
-        y: 1.2,
-        z: 8.3,
-      },
-      {
-        x: 3.4,
-        y: -2.1,
-        z: 9.3,
-      },
-    ]),
-  ).toBe('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
-});
-
-describe("Should deserialize integer arrays", () => {
-  expect(JSON.stringify(JSON.parse<u32[]>("[0,100,101]"))).toBe("[0,100,101]");
-  expect(JSON.stringify(JSON.parse<u64[]>("[0,100,101]"))).toBe("[0,100,101]");
-  expect(JSON.stringify(JSON.parse<i32[]>("[0,100,101,-100,-101]"))).toBe("[0,100,101,-100,-101]");
-  expect(JSON.stringify(JSON.parse<i64[]>("[0,100,101,-100,-101]"))).toBe("[0,100,101,-100,-101]");
-});
-
-describe("Should deserialize float arrays", () => {
-  expect(JSON.stringify(JSON.parse<f64[]>("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]"))).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
-  expect(JSON.stringify(JSON.parse<f64[]>("[1e+21,1e+22,1e-7,1e-8,1e-9]"))).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
-});
-
-describe("Should deserialize boolean arrays", () => {
-  expect(JSON.stringify(JSON.parse<bool[]>("[true,false]"))).toBe("[true,false]");
-  expect(JSON.stringify(JSON.parse<boolean[]>("[true,false]"))).toBe("[true,false]");
-});
-
-describe("Should deserialize string arrays", () => {
-  expect(JSON.stringify(JSON.parse<string[]>('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]'))).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
-});
-
-describe("Should deserialize nested integer arrays", () => {
-  expect(JSON.stringify(JSON.parse<i64[][]>("[[100,101],[-100,-101],[0]]"))).toBe("[[100,101],[-100,-101],[0]]");
-});
-
-describe("Should deserialize nested float arrays", () => {
-  expect(JSON.stringify(JSON.parse<f64[][]>("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]"))).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
-});
-
-describe("Should deserialize nested boolean arrays", () => {
-  expect(JSON.stringify(JSON.parse<bool[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
-  expect(JSON.stringify(JSON.parse<boolean[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
-});
+// describe("Should serialize integer arrays", () => {
+//   expect(JSON.stringify<u32[]>([0, 100, 101])).toBe("[0,100,101]");
+
+//   expect(JSON.stringify<u64[]>([0, 100, 101])).toBe("[0,100,101]");
+
+//   expect(JSON.stringify<i32[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
+
+//   expect(JSON.stringify<i64[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
+// });
+
+// describe("Should serialize float arrays", () => {
+//   expect(JSON.stringify<f64[]>([7.23, 10e2, 10e2, 123456e-5, 123456e-5, 0.0, 7.23])).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
+
+//   expect(JSON.stringify<f64[]>([1e21, 1e22, 1e-7, 1e-8, 1e-9])).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
+// });
+
+// describe("Should serialize boolean arrays", () => {
+//   expect(JSON.stringify<bool[]>([true, false])).toBe("[true,false]");
+
+//   expect(JSON.stringify<boolean[]>([true, false])).toBe("[true,false]");
+// });
+
+// describe("Should serialize string arrays", () => {
+//   expect(JSON.stringify<string[]>(['string "with random spa\nces and \nnewlines\n\n\n'])).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
+// });
+
+// describe("Should serialize nested integer arrays", () => {
+//   expect(JSON.stringify<i64[][]>([[100, 101], [-100, -101], [0]])).toBe("[[100,101],[-100,-101],[0]]");
+// });
+
+// describe("Should serialize nested float arrays", () => {
+//   expect(JSON.stringify<f64[][]>([[7.23], [10e2], [10e2], [123456e-5], [123456e-5], [0.0], [7.23]])).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
+// });
+
+// describe("Should serialize nested boolean arrays", () => {
+//   expect(JSON.stringify<bool[][]>([[true], [false]])).toBe("[[true],[false]]");
+
+//   expect(JSON.stringify<boolean[][]>([[true], [false]])).toBe("[[true],[false]]");
+// });
+
+// describe("Should serialize object arrays", () => {
+//   expect(
+//     JSON.stringify<Vec3[]>([
+//       {
+//         x: 3.4,
+//         y: 1.2,
+//         z: 8.3,
+//       },
+//       {
+//         x: 3.4,
+//         y: -2.1,
+//         z: 9.3,
+//       },
+//     ]),
+//   ).toBe('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
+// });
+
+// describe("Should deserialize integer arrays", () => {
+//   expect(JSON.stringify(JSON.parse<u32[]>("[0,100,101]"))).toBe("[0,100,101]");
+//   expect(JSON.stringify(JSON.parse<u64[]>("[0,100,101]"))).toBe("[0,100,101]");
+//   expect(JSON.stringify(JSON.parse<i32[]>("[0,100,101,-100,-101]"))).toBe("[0,100,101,-100,-101]");
+//   expect(JSON.stringify(JSON.parse<i64[]>("[0,100,101,-100,-101]"))).toBe("[0,100,101,-100,-101]");
+// });
+
+// describe("Should deserialize float arrays", () => {
+//   expect(JSON.stringify(JSON.parse<f64[]>("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]"))).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
+//   expect(JSON.stringify(JSON.parse<f64[]>("[1e+21,1e+22,1e-7,1e-8,1e-9]"))).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
+// });
+
+// describe("Should deserialize boolean arrays", () => {
+//   expect(JSON.stringify(JSON.parse<bool[]>("[true,false]"))).toBe("[true,false]");
+//   expect(JSON.stringify(JSON.parse<boolean[]>("[true,false]"))).toBe("[true,false]");
+// });
+
+// describe("Should deserialize string arrays", () => {
+//   expect(JSON.stringify(JSON.parse<string[]>('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]'))).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
+// });
+
+// describe("Should deserialize nested integer arrays", () => {
+//   expect(JSON.stringify(JSON.parse<i64[][]>("[[100,101],[-100,-101],[0]]"))).toBe("[[100,101],[-100,-101],[0]]");
+// });
+
+// describe("Should deserialize nested float arrays", () => {
+//   expect(JSON.stringify(JSON.parse<f64[][]>("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]"))).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
+// });
+
+// describe("Should deserialize nested boolean arrays", () => {
+//   expect(JSON.stringify(JSON.parse<bool[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
+//   expect(JSON.stringify(JSON.parse<boolean[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
+// });
 
 describe("Should deserialize object arrays", () => {
   expect(JSON.stringify(JSON.parse<Vec3[]>('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]'))).toBe('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
 });
 
-describe("Should deserialize raw arrays", () => {
-  const r1 = JSON.parse<JSON.Raw[]>('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
-  expect(r1[0].toString()).toBe('{"x":3.4,"y":1.2,"z":8.3}');
-  expect(r1[1].toString()).toBe('{"x":3.4,"y":-2.1,"z":9.3}');
-
-  const r2 = JSON.parse<JSON.Raw[][]>('[[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}],[{"x":0.1,"y":-7.3,"z":4.5}]]');
-  expect(r2[0][0].toString()).toBe('{"x":3.4,"y":1.2,"z":8.3}');
-  expect(r2[0][1].toString()).toBe('{"x":3.4,"y":-2.1,"z":9.3}');
-  expect(r2[1][0].toString()).toBe('{"x":0.1,"y":-7.3,"z":4.5}');
-
-  const r3 = JSON.parse<JSON.Raw[]>('[1,2,3,4,5]');
-  expect(r3[0]).toBe(1);
-  expect(r3[1]).toBe(2);
-  expect(r3[2]).toBe(3);
-  expect(r3[3]).toBe(4);
-  expect(r3[4]).toBe(5);
-
-  const r4 = JSON.parse<JSON.Raw[][]>('[[1,2,3,4,5],[6,7,8,9,10]]');
-  expect(r4[0][0]).toBe(1);
-  expect(r4[0][1]).toBe(2);
-  expect(r4[0][2]).toBe(3);
-  expect(r4[0][3]).toBe(4);
-  expect(r4[0][4]).toBe(5);
-
-  expect(r4[1][0]).toBe(6);
-  expect(r4[1][1]).toBe(7);
-  expect(r4[1][2]).toBe(8);
-  expect(r4[1][3]).toBe(9);
-  expect(r4[1][4]).toBe(10);
-  
-  const r5 = JSON.parse<JSON.Raw[]>('[{"x":3.4,"y":1.2,"z":8.3},[1,2,3,4,5],"12345",true,false,null,[[]]]');
-  expect(r5[0].toString()).toBe('{"x":3.4,"y":1.2,"z":8.3}');
-  expect(r5[1].toString()).toBe('[1,2,3,4,5]');
-  expect(r5[2]).toBe('"12345"');
-  expect(r5[3]).toBe(true);
-  expect(r5[4]).toBe(false);
-  expect(r5[5]).toBe(null);
-  expect(r5[6].toString()).toBe('[[]]');
-});
 
 @json
 class Vec3 {
   x: f64 = 0.0;
   y: f64 = 0.0;
   z: f64 = 0.0;
+  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {
+    let keyStart: usize = 0;
+    let keyEnd: usize = 0;
+    let isKey = false;
+    let lastIndex: usize = 0;
+
+    while (srcStart < srcEnd && JSON.Util.isSpace(load<u16>(srcStart))) srcStart += 2;
+    while (srcEnd > srcStart && JSON.Util.isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+    if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
+    if (load<u16>(srcStart) != 123) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
+    if (load<u16>(srcEnd - 2) != 125) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+    srcStart += 2;
+
+    while (srcStart < srcEnd) {
+      let code = load<u16>(srcStart);
+      while (JSON.Util.isSpace(code)) code = load<u16>((srcStart += 2));
+      if (keyStart == 0) {
+        if (code == 34 && load<u16>(srcStart - 2) !== 92) {
+          if (isKey) {
+            keyStart = lastIndex;
+            keyEnd = srcStart;
+            while (JSON.Util.isSpace((code = load<u16>((srcStart += 2))))) {}
+            if (code !== 58) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
+            isKey = false;
+          } else {
+            isKey = true;
+            lastIndex = srcStart + 2;
+          }
+        }
+        srcStart += 2;
+      } else {
+        if (code - 48 <= 9 || code == 45) {
+          lastIndex = srcStart;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
+              switch (<u32>keyEnd - <u32>keyStart) {
+                case 2: {
+                  const code16 = load<u16>(keyStart);
+                  if (code16 == 120) {
+                    // x
+                    store<f64>(changetype<usize>(out), JSON.__deserialize<f64>(lastIndex, srcStart), offsetof<this>("x"));
+                    keyStart = 0;
+                    break;
+                  } else if (code16 == 121) {
+                    // y
+                    store<f64>(changetype<usize>(out), JSON.__deserialize<f64>(lastIndex, srcStart), offsetof<this>("y"));
+                    keyStart = 0;
+                    break;
+                  } else if (code16 == 122) {
+                    // z
+                    store<f64>(changetype<usize>(out), JSON.__deserialize<f64>(lastIndex, srcStart), offsetof<this>("z"));
+                    keyStart = 0;
+                    break;
+                  }
+                }
+              }
+              break;
+            }
+            srcStart += 2;
+          }
+        } else {
+          srcStart += 2;
+        }
+      }
+    }
+    return out;
+  }
 }

package/assembly/__tests__/lib/index.ts

@@ -13,7 +13,7 @@ export function expect<T>(left: T): Expectation {
   // @ts-ignore
   if (!isDefined(left.toString)) throw new Error("Expected left to have a toString method, but it does not.");
   // @ts-ignore
-  return new Expectation(isNull(left) ? "null" : left.toString());
+  return new Expectation(left == null ? "null" : left.toString());
 }
 
 class Expectation {
@@ -26,16 +26,12 @@ class Expectation {
     // @ts-ignore
     if (!isDefined(right.toString)) throw new Error("Expected right to have a toString method, but it does not.");
     // @ts-ignore
-    if (this.left != (isNull(right) ? "null" : right.toString())) {
+    if (this.left != (right == null ? "null" : right.toString())) {
       console.log("  " + currentDescription + "\n");
       // @ts-ignore
-      console.log("  (expected) -> " + (isNull(right) ? "null" : right.toString()));
+      console.log("  (expected) -> " + (right == null ? "null" : right.toString()));
       console.log("  (received) -> " + this.left);
       unreachable();
     }
   }
 }
-
-function isNull<T>(value: T): bool {
-  return (isInteger<T>() && !isSigned<T>() && nameof<T>() == "usize" && value == 0) || (isNullable<T>() && changetype<usize>(value) == <usize>0);
-}

package/assembly/deserialize/simple/array.ts

@@ -9,7 +9,6 @@ import { deserializeStructArray } from "./array/struct";
 import { deserializeStringArray } from "./array/string";
 import { deserializeObjectArray } from "./array/object";
 import { deserializeBoxArray } from "./array/box";
-import { deserializeRawArray } from "./array/raw";
 
 // @ts-ignore: Decorator valid here
 export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
@@ -38,9 +37,6 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     } else if (type instanceof JSON.Obj) {
       // @ts-ignore: type
       return deserializeObjectArray<T>(srcStart, srcEnd, dst);
-    } else if (type instanceof JSON.Raw) {
-      // @ts-ignore: type
-      return deserializeRawArray(srcStart, srcEnd, dst);
     } else if (type instanceof Map) {
       // @ts-ignore: type
       return deserializeMapArray<T>(srcStart, srcEnd, dst);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "1.1.14-preview.1",
+  "version": "1.1.14",
   "author": "Jairus Tanaka",
   "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "types": "assembly/index.ts",

package/assembly/deserialize/simple/array/raw.ts

@@ -1,106 +0,0 @@
-import { isSpace } from "../../../util";
-import { COMMA, BRACKET_RIGHT, QUOTE, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BACK_SLASH, CHAR_T, CHAR_F, CHAR_N } from "../../../custom/chars";
-import { JSON } from "../../..";
-import { ptrToStr } from "../../../util/ptrToStr";
-
-export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Raw[] {
-  // console.log("data: " + ptrToStr(srcStart, srcEnd));
-  const out = changetype<JSON.Raw[]>(dst || changetype<usize>(instantiate<JSON.Raw[]>()));
-  let lastIndex: usize = 0;
-  let depth = 0;
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    let code = load<u16>(srcStart);
-    if (code == QUOTE) {
-      lastIndex = srcStart;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        code = load<u16>(srcStart);
-        if (code == QUOTE || isSpace(code)) {
-          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart));
-          out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 4;
-          break;
-        }
-        srcStart += 2;
-      }
-    } else if (code - 48 <= 9 || code == 45) {
-      lastIndex = srcStart;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
-          // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-          out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart)));
-          srcStart += 2;
-          break;
-        }
-        srcStart += 2;
-      }
-    } else if (code == BRACE_LEFT) {
-      lastIndex = srcStart;
-      depth++;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == QUOTE) {
-          srcStart += 2;
-          while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
-        } else if (code == BRACE_RIGHT) {
-          if (--depth == 0) {
-            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-            out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
-            srcStart += 4;
-            break;
-          }
-        } else if (code == BRACE_LEFT) depth++;
-        srcStart += 2;
-      }
-    } else if (code == BRACKET_LEFT) {
-      lastIndex = srcStart;
-      depth++;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == QUOTE) {
-          srcStart += 2;
-          while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
-        } else if (code == BRACKET_RIGHT) {
-          if (--depth == 0) {
-            // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-            out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
-            srcStart += 4;
-            break;
-          }
-        } else if (code == BRACKET_LEFT) depth++;
-        srcStart += 2;
-      }
-    } else if (code == CHAR_T) {
-      if (load<u64>(srcStart) == 28429475166421108) {
-        // console.log("Value (true): " + ptrToStr(srcStart, srcStart + 8));
-        out.push(JSON.Raw.from("true"));
-        srcStart += 10;
-      }
-    } else if (code == CHAR_F) {
-      if (load<u64>(srcStart, 2) == 28429466576093281) {
-        // console.log("Value (false): " + ptrToStr(srcStart, srcStart + 10));
-        out.push(JSON.Raw.from("false"));
-        srcStart += 12;
-      }
-    } else if (code == CHAR_N) {
-      if (load<u64>(srcStart) == 30399761348886638) {
-        // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-        out.push(JSON.Raw.from("null"));
-        srcStart += 10;
-      }
-    } else if (isSpace(code)) {
-      srcStart += 2;
-    } else {
-      throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString() + " " + ptrToStr(lastIndex, srcStart+10));
-    }
-  }
-  return out;
-}