json-as 0.9.20 → 0.9.22

package/.prettierrc.json

@@ -0,0 +1,4 @@
+{
+  "singleQuote": false,
+  "printWidth": 65536
+}

package/CHANGELOG

@@ -28,6 +28,7 @@ v0.9.17 - A schema's parent's fields should be included properly
 v0.9.18 - Should be able to use @alias and @omit*** or JSON.Raw
 v0.9.19 - Fix arguments in @omitif declarations not working properly
 v0.9.20 - Strings were being received with quotes attached via the toString functionality. Removed that.
+v0.9.22 - Fix #89 and #93. Several bug fixes some severe such as ",null" being prepended when using @omit. Properly warn when a schema has fields that are not compatible with json
 
 [UNRELEASED] v1.0.0
  - Allow nullable primitives

package/README.md

@@ -3,7 +3,7 @@
  __|  ||   __||     ||   | | ___ |  _  ||   __|
 |  |  ||__   ||  |  || | | ||___||     ||__   |
 |_____||_____||_____||_|___|     |__|__||_____|
-v0.9.20
+v0.9.22
 </pre>
 </h5>
 
@@ -107,25 +107,16 @@ const serialized = JSON.stringify(arr);
 const parsed = JSON.parse<Base[]>(serialized);
 ```
 
-Classes can even have inheritance. Here's a nasty example
-
-```js
-@json
-class Base {}
-
-const serialized = JSON.stringify(arr);
-// [{"x":1.0},{"x":1.0,"y":2.0},{"y":2.0,"x":1.0,"z":3.0}]
-const parsed = JSON.parse<Base[]>(serialized);
-```
-
 You can also add it to your `asconfig.json`
 
+```json
 {
-// ...
-"options": {
-"transform": ["json-as/transform"]
-}
+  // ...
+  "options": {
+    "transform": ["json-as/transform"]
+  }
 }
+```
 
 If you use this project in your codebase, consider dropping a [star](https://github.com/JairusSW/as-json). I would really appreciate it!
 

package/assembly/__benches__/as-tral.d.ts

@@ -0,0 +1 @@
+/// <reference types="@as-tral/cli/as-tral" />

package/assembly/__benches__/bool.bench.ts

@@ -0,0 +1,14 @@
+// import { bs } from "../custom/bs";
+// import { serializeBool, serializeBool_BS } from "../serialize/bool"
+
+// const out = memory.data(65536);
+
+// bench("Serialize Bool", () => {
+//     blackbox<string>(serializeBool(true));
+// });
+
+// bench("Serialize Bool BS", () => {
+//     serializeBool_BS(true);
+//     bs._out(out);
+//     bs.reset();
+// });

package/assembly/__benches__/simd.bench.ts

@@ -0,0 +1,36 @@
+// function esc_128(data: string): bool {
+//     let len = data.length;
+
+//     let running = v128.splat<i64>(0);
+//     let i = 0;
+
+//     while (i + 15 < len) {
+//         let w = v128.load(changetype<usize>(data));
+//         running = v128.or(running, v128.eq<i16>(w, i16x8.splat(34)));
+//         running = v128.or(running, v128.eq<i16>(w, i16x8.splat(92)));
+
+//         const subtracted = v128.sub<i16>(w, i8x16.splat(31));
+//         running = v128.or(running, v128.eq<i16>(subtracted, v128.splat<i64>(0)));
+//         i += 16;
+//     }
+
+//     return v128.any_true(running);
+// }
+
+// function esc_16(data: string): bool {
+//     let len = data.length;
+//     let b: u16 = 0;
+//     while (len--) {
+//         const c = load<u16>(changetype<usize>(data) + (len << 1));
+//         b |= u16(c < 32) | u16(c == 34) | u16(c == 92);
+//     }
+//     return bool(b);
+// }
+
+// bench("needs escaping 128", () => {
+//     blackbox<bool>(esc_128("hel\"o !!"));
+// })
+
+// bench("needs escaping 16", () => {
+//     blackbox<bool>(esc_16("hel\"o !!"));
+// })

package/assembly/__benches__/string.bench.ts

@@ -0,0 +1,21 @@
+import { bs } from "../custom/bs";
+import { serializeBool, serializeBool_BS } from "../serialize/bool";
+import { serialize_simd_v1, serializeString, serializeString_BS } from "../serialize/string";
+
+const out = memory.data(65536);
+
+bench("UTF-16 to UTF-8", () => {
+  blackbox<ArrayBuffer>(String.UTF8.encode(blackbox<string>("hello world")));
+});
+// bench("Serialize String Native", () => {
+//     blackbox<string>(serializeString("hello \"world abc"));
+// });
+
+// bench("Serialize String Sink", () => {
+//     serializeString_BS("hello \"world abc");
+//     bs.reset();
+// });
+
+// bench("Serialize String SIMD", () => {
+//     serialize_simd_v1("hello \"world abc", out);
+// })

package/assembly/__tests__/bool.spec.ts

@@ -0,0 +1,20 @@
+import { JSON } from "json-as";
+import { describe, expect, run } from "as-test/assembly";
+
+describe("Should serialize booleans", () => {
+  expect(JSON.stringify<bool>(true)).toBe("true");
+
+  expect(JSON.stringify<bool>(false)).toBe("false");
+
+  expect(JSON.stringify<boolean>(true)).toBe("true");
+
+  expect(JSON.stringify<boolean>(false)).toBe("false");
+});
+
+describe("Should deserialize booleans", () => {
+  expect(JSON.parse<boolean>("true")).toBe(true);
+
+  expect(JSON.parse<boolean>("false")).toBe(false);
+});
+
+run();

package/assembly/__tests__/float.spec.ts

@@ -0,0 +1,52 @@
+import { JSON } from "json-as";
+import { describe, expect, run } from "as-test/assembly";
+
+describe("Should serialize floats", () => {
+  expect(JSON.stringify<f64>(7.23)).toBe("7.23");
+
+  expect(JSON.stringify<f64>(10e2)).toBe("1000.0");
+
+  expect(JSON.stringify<f64>(123456e-5)).toBe("1.23456");
+
+  expect(JSON.stringify<f64>(0.0)).toBe("0.0");
+
+  expect(JSON.stringify<f64>(-7.23)).toBe("-7.23");
+
+  expect(JSON.stringify<f64>(1e-6)).toBe("0.000001");
+
+  expect(JSON.stringify<f64>(1e-7)).toBe("1e-7");
+
+  expect(JSON.parse<f64>("1E-7")).toBe(1e-7);
+
+  expect(JSON.stringify<f64>(1e20)).toBe("100000000000000000000.0");
+
+  expect(JSON.stringify<f64>(1e21)).toBe("1e+21");
+
+  expect(JSON.parse<f64>("1E+21")).toBe(1e21);
+
+  expect(JSON.parse<f64>("1e21")).toBe(1e21);
+
+  expect(JSON.parse<f64>("1E21")).toBe(1e21);
+});
+
+describe("Should deserialize floats", () => {
+  expect(JSON.parse<f64>("7.23")).toBe(7.23);
+
+  expect(JSON.parse<f64>("1000.0")).toBe(1000.0);
+
+  expect(JSON.parse<f64>("1.23456")).toBe(1.23456);
+
+  expect(JSON.parse<f64>("0.0")).toBe(0.0);
+
+  expect(JSON.parse<f64>("-7.23")).toBe(-7.23);
+
+  expect(JSON.parse<f64>("0.000001")).toBe(0.000001);
+
+  expect(JSON.parse<f64>("1e-7")).toBe(1e-7);
+
+  expect(JSON.parse<f64>("100000000000000000000.0")).toBe(1e20);
+
+  expect(JSON.parse<f64>("1e+21")).toBe(1e21);
+});
+
+run();

package/assembly/__tests__/integer.spec.ts

@@ -0,0 +1,28 @@
+import { JSON } from "json-as";
+import { describe, expect, run } from "as-test/assembly";
+
+describe("Should serialize integers", () => {
+  expect(JSON.stringify(0)).toBe("0");
+
+  expect(JSON.stringify<u32>(100)).toBe("100");
+
+  expect(JSON.stringify<u64>(101)).toBe("101");
+
+  expect(JSON.stringify<i32>(-100)).toBe("-100");
+
+  expect(JSON.stringify<i64>(-101)).toBe("-101");
+});
+
+describe("Should deserialize integers", () => {
+  expect(JSON.parse<i32>("0")).toBe(<i32>0);
+
+  expect(JSON.parse<u32>("100")).toBe(<u32>100);
+
+  expect(JSON.parse<u64>("101")).toBe(<u64>101);
+
+  expect(JSON.parse<i32>("-100")).toBe(<i32>-100);
+
+  expect(JSON.parse<i64>("-101")).toBe(<i64>-101);
+});
+
+run();

package/assembly/__tests__/obj.spec.ts

@@ -0,0 +1,4 @@
+import { JSON } from "json-as";
+import { describe, expect, run } from "as-test/assembly";
+
+run();

package/assembly/__tests__/string.spec.ts

@@ -0,0 +1,24 @@
+import { JSON } from "json-as";
+import { describe, expect, run } from "as-test/assembly";
+
+describe("Should serialize strings", () => {
+  expect(JSON.stringify("abcdefg")).toBe('"abcdefg"');
+
+  expect(JSON.stringify('st"ring" w""ith quotes"')).toBe('"st\\"ring\\" w\\"\\"ith quotes\\""');
+
+  expect(JSON.stringify('string "with random spa\nces and \nnewlines\n\n\n')).toBe('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"');
+
+  expect(JSON.stringify('string with colon : comma , brace [ ] bracket { } and quote " and other quote \\"')).toBe('"string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\\\\\""');
+});
+
+describe("Should deserialize strings", () => {
+  expect(JSON.parse<string>('"abcdefg"')).toBe("abcdefg");
+
+  expect(JSON.parse<string>('"\\"st\\\\\\"ring\\\\\\" w\\\\\\"\\\\\\"ith quotes\\\\\\"\\""')).toBe('"st\\"ring\\" w\\"\\"ith quotes\\""');
+
+  expect(JSON.parse<string>('"\\"string \\\\\\"with random spa\\\\nces and \\\\nnewlines\\\\n\\\\n\\\\n\\""')).toBe('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"');
+
+  expect(JSON.parse<string>('"\\"string with colon : comma , brace [ ] bracket { } and quote \\\\\\" and other quote \\\\\\\\\\"\\""')).toBe('"string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\\\""');
+});
+
+run();

package/assembly/__tests__/test.spec.ts

@@ -1,84 +1,6 @@
 import { JSON } from "json-as";
 import { describe, expect, run } from "as-test/assembly";
-import {
-  DerivedObject,
-  Null,
-  ObjWithStrangeKey,
-  ObjectWithFloat,
-  OmitIf,
-  Player,
-  Vec3,
-} from "./types";
-
-describe("Should serialize strings", () => {
-  expect(JSON.stringify("abcdefg")).toBe('"abcdefg"');
-
-  expect(JSON.stringify('st"ring" w""ith quotes"')).toBe(
-    '"st\\"ring\\" w\\"\\"ith quotes\\""',
-  );
-
-  expect(
-    JSON.stringify('string "with random spa\nces and \nnewlines\n\n\n'),
-  ).toBe('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"');
-
-  expect(
-    JSON.stringify(
-      'string with colon : comma , brace [ ] bracket { } and quote " and other quote \\"',
-    ),
-  ).toBe(
-    '"string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\\\\\""',
-  );
-});
-
-describe("Should serialize integers", () => {
-  expect(JSON.stringify(0)).toBe("0");
-
-  expect(JSON.stringify<u32>(100)).toBe("100");
-
-  expect(JSON.stringify<u64>(101)).toBe("101");
-
-  expect(JSON.stringify<i32>(-100)).toBe("-100");
-
-  expect(JSON.stringify<i64>(-101)).toBe("-101");
-});
-
-describe("Should serialize floats", () => {
-  expect(JSON.stringify<f64>(7.23)).toBe("7.23");
-
-  expect(JSON.stringify<f64>(10e2)).toBe("1000.0");
-
-  expect(JSON.stringify<f64>(123456e-5)).toBe("1.23456");
-
-  expect(JSON.stringify<f64>(0.0)).toBe("0.0");
-
-  expect(JSON.stringify<f64>(-7.23)).toBe("-7.23");
-
-  expect(JSON.stringify<f64>(1e-6)).toBe("0.000001");
-
-  expect(JSON.stringify<f64>(1e-7)).toBe("1e-7");
-
-  expect(JSON.parse<f64>("1E-7")).toBe(1e-7);
-
-  expect(JSON.stringify<f64>(1e20)).toBe("100000000000000000000.0");
-
-  expect(JSON.stringify<f64>(1e21)).toBe("1e+21");
-
-  expect(JSON.parse<f64>("1E+21")).toBe(1e21);
-
-  expect(JSON.parse<f64>("1e21")).toBe(1e21);
-
-  expect(JSON.parse<f64>("1E21")).toBe(1e21);
-});
-
-describe("Should serialize booleans", () => {
-  expect(JSON.stringify<bool>(true)).toBe("true");
-
-  expect(JSON.stringify<bool>(false)).toBe("false");
-
-  expect(JSON.stringify<boolean>(true)).toBe("true");
-
-  expect(JSON.stringify<boolean>(false)).toBe("false");
-});
+import { DerivedObject, Null, ObjWithStrangeKey, ObjectWithFloat, OmitIf, Player, Vec3 } from "./types";
 
 describe("Should serialize class inheritance", () => {
   const obj = new DerivedObject("1", "2");
@@ -95,23 +17,15 @@ describe("Should serialize integer arrays", () => {
 
   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<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]",
-  );
+  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[]>([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]",
-  );
+  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", () => {
@@ -121,39 +35,21 @@ describe("Should serialize boolean arrays", () => {
 });
 
 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"]');
+  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]]",
-  );
+  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]]");
+  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]]",
-  );
+  expect(JSON.stringify<boolean[][]>([[true], [false]])).toBe("[[true],[false]]");
 });
 
 describe("Should serialize object arrays", () => {
@@ -195,27 +91,19 @@ describe("Should serialize objects", () => {
       },
       isVerified: true,
     }),
-  ).toBe(
-    '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}',
-  );
+  ).toBe('{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}');
 
   expect(JSON.stringify<ObjectWithFloat>({ f: 7.23 })).toBe('{"f":7.23}');
 
-  expect(JSON.stringify<ObjectWithFloat>({ f: 0.000001 })).toBe(
-    '{"f":0.000001}',
-  );
+  expect(JSON.stringify<ObjectWithFloat>({ f: 0.000001 })).toBe('{"f":0.000001}');
 
   expect(JSON.stringify<ObjectWithFloat>({ f: 1e-7 })).toBe('{"f":1e-7}');
 
-  expect(JSON.stringify<ObjectWithFloat>({ f: 1e20 })).toBe(
-    '{"f":100000000000000000000.0}',
-  );
+  expect(JSON.stringify<ObjectWithFloat>({ f: 1e20 })).toBe('{"f":100000000000000000000.0}');
 
   expect(JSON.stringify<ObjectWithFloat>({ f: 1e21 })).toBe('{"f":1e+21}');
 
-  expect(JSON.stringify<ObjWithStrangeKey<string>>({ data: "foo" })).toBe(
-    '{"a\\\\\\t\\"\\u0002b`c":"foo"}',
-  );
+  expect(JSON.stringify<ObjWithStrangeKey<string>>({ data: "foo" })).toBe('{"a\\\\\\t\\"\\u0002b`c":"foo"}');
 });
 
 describe("Should serialize @omit'ed objects", () => {
@@ -225,69 +113,6 @@ describe("Should serialize @omit'ed objects", () => {
     }),
   ).toBe('{"x":1,"y":1,"z":1}');
 });
-
-describe("Should deserialize strings", () => {
-  expect(JSON.parse<string>('"abcdefg"')).toBe("abcdefg");
-
-  expect(
-    JSON.parse<string>(
-      '"\\"st\\\\\\"ring\\\\\\" w\\\\\\"\\\\\\"ith quotes\\\\\\"\\""',
-    ),
-  ).toBe('"st\\"ring\\" w\\"\\"ith quotes\\""');
-
-  expect(
-    JSON.parse<string>(
-      '"\\"string \\\\\\"with random spa\\\\nces and \\\\nnewlines\\\\n\\\\n\\\\n\\""',
-    ),
-  ).toBe('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"');
-
-  expect(
-    JSON.parse<string>(
-      '"\\"string with colon : comma , brace [ ] bracket { } and quote \\\\\\" and other quote \\\\\\\\\\"\\""',
-    ),
-  ).toBe(
-    '"string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\\\""',
-  );
-});
-
-describe("Should deserialize integers", () => {
-  expect(JSON.parse<i32>("0")).toBe(<i32>0);
-
-  expect(JSON.parse<u32>("100")).toBe(<u32>100);
-
-  expect(JSON.parse<u64>("101")).toBe(<u64>101);
-
-  expect(JSON.parse<i32>("-100")).toBe(<i32>-100);
-
-  expect(JSON.parse<i64>("-101")).toBe(<i64>-101);
-});
-
-describe("Should deserialize floats", () => {
-  expect(JSON.parse<f64>("7.23")).toBe(7.23);
-
-  expect(JSON.parse<f64>("1000.0")).toBe(1000.0);
-
-  expect(JSON.parse<f64>("1.23456")).toBe(1.23456);
-
-  expect(JSON.parse<f64>("0.0")).toBe(0.0);
-
-  expect(JSON.parse<f64>("-7.23")).toBe(-7.23);
-
-  expect(JSON.parse<f64>("0.000001")).toBe(0.000001);
-
-  expect(JSON.parse<f64>("1e-7")).toBe(1e-7);
-
-  expect(JSON.parse<f64>("100000000000000000000.0")).toBe(1e20);
-
-  expect(JSON.parse<f64>("1e+21")).toBe(1e21);
-});
-
-describe("Should deserialize booleans", () => {
-  expect(JSON.parse<boolean>("true")).toBe(true);
-
-  expect(JSON.parse<boolean>("false")).toBe(false);
-});
-
 describe("Should deserialize class inheritance", () => {
   const jsonStr = '{"a":"1","b":"2"}';
   const obj = JSON.parse<DerivedObject>(jsonStr);
@@ -302,83 +127,39 @@ describe("Should deserialize nulls", () => {
 });
 
 describe("Should deserialize integer arrays", () => {
-  expect(JSON.stringify(JSON.parse<u32[]>("[0,100,101]"))).toBe(
-    JSON.stringify([0, 100, 101]),
-  );
+  expect(JSON.stringify(JSON.parse<u32[]>("[0,100,101]"))).toBe(JSON.stringify([0, 100, 101]));
 
-  expect(JSON.stringify(JSON.parse<i32[]>("[0,100,101,-100,-101]"))).toBe(
-    JSON.stringify([0, 100, 101, -100, -101]),
-  );
+  expect(JSON.stringify(JSON.parse<i32[]>("[0,100,101,-100,-101]"))).toBe(JSON.stringify([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(JSON.stringify([7.23, 1000.0, 1000.0, 1.23456, 1.23456, 0.0, 7.23]));
+  expect(JSON.stringify(JSON.parse<f64[]>("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]"))).toBe(JSON.stringify([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(JSON.stringify([1e21, 1e22, 1e-7, 1e-8, 1e-9]));
+  expect(JSON.stringify(JSON.parse<f64[]>("[1e+21,1e+22,1e-7,1e-8,1e-9]"))).toBe(JSON.stringify([1e21, 1e22, 1e-7, 1e-8, 1e-9]));
 });
 
 describe("Should deserialize boolean arrays", () => {
-  expect(JSON.stringify(JSON.parse<boolean[]>("[true,false]"))).toBe(
-    JSON.stringify([true, false]),
-  );
+  expect(JSON.stringify(JSON.parse<boolean[]>("[true,false]"))).toBe(JSON.stringify([true, false]));
 });
 
 describe("Should deserialize string arrays", () => {
-  expect(
-    JSON.stringify(
-      JSON.parse<string[]>(
-        '["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]',
-      ),
-    ),
-  ).toBe(JSON.stringify(['string "with random spa\nces and \nnewlines\n\n\n']));
+  expect(JSON.stringify(JSON.parse<string[]>('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]'))).toBe(JSON.stringify(['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(JSON.stringify([[100, 101], [-100, -101], [0]]));
+  expect(JSON.stringify(JSON.parse<i64[][]>("[[100,101],[-100,-101],[0]]"))).toBe(JSON.stringify([[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(
-    JSON.stringify([
-      [7.23],
-      [1000.0],
-      [1000.0],
-      [1.23456],
-      [1.23456],
-      [0.0],
-      [7.23],
-    ]),
-  );
+  expect(JSON.stringify(JSON.parse<f64[][]>("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]"))).toBe(JSON.stringify([[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<boolean[][]>("[[true],[false]]"))).toBe(
-    JSON.stringify([[true], [false]]),
-  );
+  expect(JSON.stringify(JSON.parse<boolean[][]>("[[true],[false]]"))).toBe(JSON.stringify([[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(
+  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(
     JSON.stringify(<Vec3[]>[
       { x: 3.4, y: 1.2, z: 8.3 },
       { x: 3.4, y: -2.1, z: 9.3 },
@@ -387,17 +168,9 @@ describe("Should deserialize object arrays", () => {
 });
 
 describe("Should deserialize Objects", () => {
-  expect(JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}'))).toBe(
-    JSON.stringify(<Vec3>{ x: 3.4, y: 1.2, z: 8.3 }),
-  );
+  expect(JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}'))).toBe(JSON.stringify(<Vec3>{ x: 3.4, y: 1.2, z: 8.3 }));
 
-  expect(
-    JSON.stringify(
-      JSON.parse<Player>(
-        '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}',
-      ),
-    ),
-  ).toBe(
+  expect(JSON.stringify(JSON.parse<Player>('{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}'))).toBe(
     JSON.stringify(<Player>{
       firstName: "Emmet",
       lastName: "West",
@@ -408,19 +181,11 @@ describe("Should deserialize Objects", () => {
     }),
   );
 
-  expect(JSON.stringify(JSON.parse<ObjectWithFloat>('{"f":7.23}'))).toBe(
-    JSON.stringify(<ObjectWithFloat>{ f: 7.23 }),
-  );
+  expect(JSON.stringify(JSON.parse<ObjectWithFloat>('{"f":7.23}'))).toBe(JSON.stringify(<ObjectWithFloat>{ f: 7.23 }));
 
-  expect(JSON.stringify(JSON.parse<ObjectWithFloat>('{"f":0.000001}'))).toBe(
-    JSON.stringify(<ObjectWithFloat>{ f: 0.000001 }),
-  );
+  expect(JSON.stringify(JSON.parse<ObjectWithFloat>('{"f":0.000001}'))).toBe(JSON.stringify(<ObjectWithFloat>{ f: 0.000001 }));
 
-  expect(
-    JSON.stringify(
-      JSON.parse<ObjWithStrangeKey<string>>('{"a\\\\\\t\\"\\u0002b`c":"foo"}'),
-    ),
-  ).toBe(JSON.stringify(<ObjWithStrangeKey<string>>{ data: "foo" }));
+  expect(JSON.stringify(JSON.parse<ObjWithStrangeKey<string>>('{"a\\\\\\t\\"\\u0002b`c":"foo"}'))).toBe(JSON.stringify(<ObjWithStrangeKey<string>>{ data: "foo" }));
 });
 
 run({