json-as 0.9.21 → 0.9.23

package/.prettierrc.json

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

package/CHANGELOG

@@ -28,7 +28,8 @@ 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.21 - Fix #89
+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
+v0.9.23 - Comment out SIMD-related code for now
 
 [UNRELEASED] v1.0.0
  - Allow nullable primitives

package/README.md

@@ -3,7 +3,7 @@
  __|  ||   __||     ||   | | ___ |  _  ||   __|
 |  |  ||__   ||  |  || | | ||___||     ||__   |
 |_____||_____||_____||_|___|     |__|__||_____|
-v0.9.21
+v0.9.23
 </pre>
 </h5>
 
@@ -116,7 +116,7 @@ You can also add it to your `asconfig.json`
     "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

@@ -2,19 +2,19 @@ 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>(true)).toBe("true");
 
-    expect(JSON.stringify<bool>(false)).toBe("false");
+  expect(JSON.stringify<bool>(false)).toBe("false");
 
-    expect(JSON.stringify<boolean>(true)).toBe("true");
+  expect(JSON.stringify<boolean>(true)).toBe("true");
 
-    expect(JSON.stringify<boolean>(false)).toBe("false");
+  expect(JSON.stringify<boolean>(false)).toBe("false");
 });
 
 describe("Should deserialize booleans", () => {
-    expect(JSON.parse<boolean>("true")).toBe(true);
+  expect(JSON.parse<boolean>("true")).toBe(true);
 
-    expect(JSON.parse<boolean>("false")).toBe(false);
+  expect(JSON.parse<boolean>("false")).toBe(false);
 });
 
-run();
+run();

package/assembly/__tests__/float.spec.ts

@@ -2,51 +2,51 @@ 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>(7.23)).toBe("7.23");
 
-    expect(JSON.stringify<f64>(10e2)).toBe("1000.0");
+  expect(JSON.stringify<f64>(10e2)).toBe("1000.0");
 
-    expect(JSON.stringify<f64>(123456e-5)).toBe("1.23456");
+  expect(JSON.stringify<f64>(123456e-5)).toBe("1.23456");
 
-    expect(JSON.stringify<f64>(0.0)).toBe("0.0");
+  expect(JSON.stringify<f64>(0.0)).toBe("0.0");
 
-    expect(JSON.stringify<f64>(-7.23)).toBe("-7.23");
+  expect(JSON.stringify<f64>(-7.23)).toBe("-7.23");
 
-    expect(JSON.stringify<f64>(1e-6)).toBe("0.000001");
+  expect(JSON.stringify<f64>(1e-6)).toBe("0.000001");
 
-    expect(JSON.stringify<f64>(1e-7)).toBe("1e-7");
+  expect(JSON.stringify<f64>(1e-7)).toBe("1e-7");
 
-    expect(JSON.parse<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>(1e20)).toBe("100000000000000000000.0");
 
-    expect(JSON.stringify<f64>(1e21)).toBe("1e+21");
+  expect(JSON.stringify<f64>(1e21)).toBe("1e+21");
 
-    expect(JSON.parse<f64>("1E+21")).toBe(1e21);
+  expect(JSON.parse<f64>("1E+21")).toBe(1e21);
 
-    expect(JSON.parse<f64>("1e21")).toBe(1e21);
+  expect(JSON.parse<f64>("1e21")).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>("7.23")).toBe(7.23);
 
-    expect(JSON.parse<f64>("1000.0")).toBe(1000.0);
+  expect(JSON.parse<f64>("1000.0")).toBe(1000.0);
 
-    expect(JSON.parse<f64>("1.23456")).toBe(1.23456);
+  expect(JSON.parse<f64>("1.23456")).toBe(1.23456);
 
-    expect(JSON.parse<f64>("0.0")).toBe(0.0);
+  expect(JSON.parse<f64>("0.0")).toBe(0.0);
 
-    expect(JSON.parse<f64>("-7.23")).toBe(-7.23);
+  expect(JSON.parse<f64>("-7.23")).toBe(-7.23);
 
-    expect(JSON.parse<f64>("0.000001")).toBe(0.000001);
+  expect(JSON.parse<f64>("0.000001")).toBe(0.000001);
 
-    expect(JSON.parse<f64>("1e-7")).toBe(1e-7);
+  expect(JSON.parse<f64>("1e-7")).toBe(1e-7);
 
-    expect(JSON.parse<f64>("100000000000000000000.0")).toBe(1e20);
+  expect(JSON.parse<f64>("100000000000000000000.0")).toBe(1e20);
 
-    expect(JSON.parse<f64>("1e+21")).toBe(1e21);
+  expect(JSON.parse<f64>("1e+21")).toBe(1e21);
 });
 
-run();
+run();

package/assembly/__tests__/integer.spec.ts

@@ -2,27 +2,27 @@ 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(0)).toBe("0");
 
-    expect(JSON.stringify<u32>(100)).toBe("100");
+  expect(JSON.stringify<u32>(100)).toBe("100");
 
-    expect(JSON.stringify<u64>(101)).toBe("101");
+  expect(JSON.stringify<u64>(101)).toBe("101");
 
-    expect(JSON.stringify<i32>(-100)).toBe("-100");
+  expect(JSON.stringify<i32>(-100)).toBe("-100");
 
-    expect(JSON.stringify<i64>(-101)).toBe("-101");
+  expect(JSON.stringify<i64>(-101)).toBe("-101");
 });
 
 describe("Should deserialize integers", () => {
-    expect(JSON.parse<i32>("0")).toBe(<i32>0);
+  expect(JSON.parse<i32>("0")).toBe(<i32>0);
 
-    expect(JSON.parse<u32>("100")).toBe(<u32>100);
+  expect(JSON.parse<u32>("100")).toBe(<u32>100);
 
-    expect(JSON.parse<u64>("101")).toBe(<u64>101);
+  expect(JSON.parse<u64>("101")).toBe(<u64>101);
 
-    expect(JSON.parse<i32>("-100")).toBe(<i32>-100);
+  expect(JSON.parse<i32>("-100")).toBe(<i32>-100);
 
-    expect(JSON.parse<i64>("-101")).toBe(<i64>-101);
+  expect(JSON.parse<i64>("-101")).toBe(<i64>-101);
 });
 
-run();
+run();

package/assembly/__tests__/obj.spec.ts

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

package/assembly/__tests__/string.spec.ts

@@ -2,47 +2,23 @@ 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 \\\\\\""',
-    );
+  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();
+  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,14 +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";
+import { DerivedObject, Null, ObjWithStrangeKey, ObjectWithFloat, OmitIf, Player, Vec3 } from "./types";
 
 describe("Should serialize class inheritance", () => {
   const obj = new DerivedObject("1", "2");
@@ -25,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", () => {
@@ -51,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", () => {
@@ -125,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", () => {
@@ -169,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 },
@@ -254,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",
@@ -275,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({