json-as 1.1.26 → 1.2.0

package/assembly/__benches__/lib/bench.ts

@@ -1,3 +1,21 @@
+import { JSON } from "../..";
+// @ts-ignore: decorator allowed
+@external("env", "writeFile")
+declare function writeFile(fileName: string, data: string): void;
+
+@json
+class BenchResult {
+  language: string = "assemblyscript";
+  description!: string;
+  elapsed!: f64;
+  bytes!: u64;
+  operations!: u64;
+  features!: string[];
+  mbps!: f64;
+  gbps!: f64;
+}
+
+let result: BenchResult | null = null;
 export function bench(description: string, routine: () => void, ops: u64 = 1_000_000, bytesPerOp: u64 = 0): void {
   console.log(" - Benchmarking " + description);
 
@@ -20,15 +38,34 @@ export function bench(description: string, routine: () => void, ops: u64 = 1_000
 
   let log = `   Completed benchmark in ${formatNumber(u64(Math.round(elapsed)))}ms at ${formatNumber(u64(Math.round(opsPerSecond)))} ops/s`;
 
+  let mbPerSec: f64 = 0;
   if (bytesPerOp > 0) {
     const totalBytes = bytesPerOp * ops;
-    const mbPerSec = f64(totalBytes) / (elapsed / 1000) / (1000 * 1000);
+    mbPerSec = f64(totalBytes) / (elapsed / 1000) / (1000 * 1000);
     log += ` @ ${formatNumber(u64(Math.round(mbPerSec)))}MB/s`;
   }
 
+  const features: string[] = [];
+  if (ASC_FEATURE_SIMD) features.push("simd");
+
+  result = {
+    language: "assemblycript",
+    description,
+    elapsed,
+    bytes: bytesPerOp,
+    operations: ops,
+    features,
+    mbps: mbPerSec,
+    gbps: mbPerSec / 1000
+  }
+  
   console.log(log + "\n");
 }
 
+export function dumpToFile(suite: string, type: string): void {
+  writeFile("./build/logs/as/"+ (ASC_FEATURE_SIMD ? "simd/" : "swar/") + suite+"."+type+".as.json", JSON.stringify(result));
+}
+
 function formatNumber(n: u64): string {
   let str = n.toString();
   let len = str.length;
@@ -40,3 +77,9 @@ function formatNumber(n: u64): string {
   }
   return result;
 }
+
+const blackBoxArea = memory.data(64);
+export function blackbox<T>(value: T): T {
+  store<T>(blackBoxArea, value);
+  return load<T>(blackBoxArea);
+}

package/assembly/__benches__/medium.bench.ts

@@ -1,49 +1,128 @@
 import { JSON } from "..";
 import { expect } from "../__tests__/lib";
-import { bench } from "./lib/bench";
+import { bench, blackbox, dumpToFile } from "./lib/bench";
 
+@json
+class UserPreferences {
+  theme!: string;
+  notifications!: boolean;
+  language!: string;
+  timezone!: string;
+  privacy_level!: string;
+  two_factor_enabled!: boolean;
+}
 
 @json
-class MediumJSON {
-  public id!: i32;
-  public name!: string;
-  public age!: i32;
-  public email!: string;
-  public street!: string;
-  public city!: string;
-  public state!: string;
-  public zip!: string;
-  public tags!: string[];
+class RecentActivity {
+  action!: string;
+  timestamp!: string;
+  target!: string;
 }
 
-const v1: MediumJSON = {
-  id: 2,
-  name: "Medium Object",
-  age: 18,
-  email: "me@jairus.dev",
-  street: "I don't want to say my street",
-  city: "I don't want to say this either",
-  state: "It really depends",
-  zip: "I forget what it is",
-  tags: ["me", "dogs", "mountains", "bar", "foo"],
-};
+@json
+class MediumAPIResponse {
+  id!: i32;
+  username!: string;
+  full_name!: string;
+  email!: string;
+  avatar_url!: string;
+  bio!: string;
+  website!: string;
+  location!: string;
+  joined_at!: string;
+  is_verified!: boolean;
+  is_premium!: boolean;
+  follower_count!: i32;
+  following_count!: i32;
+
+  preferences!: UserPreferences;
+  tags!: string[];
+
+  recent_activity!: RecentActivity[];
+}
+
+const v1 = new MediumAPIResponse();
+const prefs = new UserPreferences();
+
+prefs.theme = "dark";
+prefs.notifications = true;
+prefs.language = "en-US";
+prefs.timezone = "America/Los_Angeles";
+prefs.privacy_level = "friends_only";
+prefs.two_factor_enabled = false;
+
+v1.id = 42;
+v1.username = "jairus";
+v1.full_name = "Jairus Tanaka";
+v1.email = "me@jairus.dev";
+v1.avatar_url = "https://avatars.githubusercontent.com/u/123456?v=4";
+v1.bio = "I like compilers, elegant algorithms, bare metal, simd, and wasm.";
+v1.website = "https://jairus.dev/";
+v1.location = "Seattle, WA";
+v1.joined_at = "2020-01-15T08:30:00Z";
+v1.is_verified = true;
+v1.is_premium = true;
+v1.follower_count = 61;
+v1.following_count = 39;
+
+v1.preferences = prefs;
+
+v1.tags = ["typescript", "webassembly", "performance", "rust", "assemblyscript", "json"];
+
+v1.recent_activity = new Array<RecentActivity>(5);
+
+let act0 = new RecentActivity();
+act0.action = "starred";
+act0.timestamp = "2025-12-22T10:15:00Z";
+act0.target = "assemblyscript/json-as";
+v1.recent_activity[0] = act0;
+
+let act1 = new RecentActivity();
+act1.action = "commented";
+act1.timestamp = "2025-12-22T09:42:00Z";
+act1.target = "issue #142";
+v1.recent_activity[1] = act1;
+
+let act2 = new RecentActivity();
+act2.action = "pushed";
+act2.timestamp = "2025-12-21T23:58:00Z";
+act2.target = "main branch";
+v1.recent_activity[2] = act2;
+
+let act3 = new RecentActivity();
+act3.action = "forked";
+act3.timestamp = "2025-12-21T18:20:00Z";
+act3.target = "fast-json-wasm";
+v1.recent_activity[3] = act3;
+
+let act4 = new RecentActivity();
+act4.action = "created";
+act4.timestamp = "2025-12-21T14:10:00Z";
+act4.target = "new benchmark suite";
+v1.recent_activity[4] = act4;
 
-const v2 = `{"id":2,"name":"Medium Object","age":18,"email":"me@jairus.dev","street":"I don't want to say my street","city":"I don't want to say this either","state":"It really depends","zip":"I forget what it is","tags":["me","dogs","mountains","bar","foo"]}`;
+const v2: string = JSON.stringify<MediumAPIResponse>(v1);
+const byteLength: usize = v2.length << 1;
 
 expect(JSON.stringify(v1)).toBe(v2);
+expect(JSON.stringify(JSON.parse<MediumAPIResponse>(v2))).toBe(v2);
 
 bench(
-  "Serialize Medium Object",
+  "Serialize Medium API Response",
   () => {
-    JSON.stringify(v1);
+    blackbox(inline.always(JSON.stringify<MediumAPIResponse>(v1)));
   },
-  6_000_00,
+  500_000,
+  byteLength
 );
+dumpToFile("medium", "serialize")
 
 bench(
-  "Deserialize Medium Object",
+  "Deserialize Medium API Response",
   () => {
-    JSON.parse<MediumJSON>(v2);
+    blackbox(inline.always(JSON.parse<MediumAPIResponse>(v2)));
   },
-  6_000_00,
+  500_000,
+  byteLength
 );
+dumpToFile("medium", "deserialize")

package/assembly/__benches__/small.bench.ts

@@ -1,36 +1,46 @@
 import { JSON } from "..";
 import { expect } from "../__tests__/lib";
-import { bench } from "./lib/bench";
-
+import { bench, blackbox, dumpToFile } from "./lib/bench";
 
 @json
-class SmallJSON {
-  public id!: i32;
-  public name!: string;
-  public active!: boolean;
+class SessionStatusResponse {
+  authenticated!: boolean;
+  user_id!: i32;
+  username!: string;
+  role!: string;
+  expires_at!: string;
 }
 
-const v1: SmallJSON = {
-  id: 1,
-  name: "Small Object",
-  active: true,
-};
-const v2 = '{"id":1,"name":"Small Object","active":true}';
+const v1 = new SessionStatusResponse();
+
+v1.authenticated = true;
+v1.user_id = 8472;
+v1.username = "jairus";
+v1.role = "admin";
+v1.expires_at = "2025-12-23T04:30:00Z";
+
+const v2: string = JSON.stringify<SessionStatusResponse>(v1);
+const byteLength: usize = v2.length << 1;
 
 expect(JSON.stringify(v1)).toBe(v2);
+expect(JSON.stringify(JSON.parse<SessionStatusResponse>(v2))).toBe(v2);
 
 bench(
-  "Serialize Small Object",
+  "Serialize Small API Response",
   () => {
-    JSON.stringify(v1);
+    blackbox(inline.always(JSON.stringify<SessionStatusResponse>(v1)));
   },
-  16_000_00,
+  5_000_000,
+  byteLength
 );
+dumpToFile("small", "serialize")
 
 bench(
-  "Deserialize Small Object",
+  "Deserialize Small API Response",
   () => {
-    JSON.parse<SmallJSON>(v2);
+    blackbox(inline.always(JSON.parse<SessionStatusResponse>(v2)));
   },
-  16_000_00,
+  5_000_000,
+  byteLength
 );
+dumpToFile("small", "deserialize")

package/assembly/__benches__/throughput.ts

@@ -0,0 +1,172 @@
+import { JSON } from "..";
+import { bs } from "../../lib/as-bs";
+import { expect } from "../__tests__/lib";
+import { bytes } from "../util";
+import { bench, blackbox, dumpToFile } from "./lib/bench";
+
+// @json // 256b
+// class ObjSmall {
+//   lorum: i32 = I32.MAX_VALUE;
+//   ipsum: boolean = true;
+//   dolor: Array<i32> = [1];
+//   sit: string = "abcdefghijklmnopdasfqrstfuvwYZ1234567890`~!@#$%^&*()_+=-{}][\\|;\":'<>,./?";
+// }
+
+// @json // 512b
+// class ObjMedium {
+//   lorum: u32 = U32.MAX_VALUE;
+//   ipsum: boolean = true;
+//   dolor: Array<i32> = [1,2,3,4,5];
+//   sit: string = "abcdefghijklmnopdasfqrstfuvwYZ1234567890`~!@#$%^&*()_+=-{}][\\|;\":'<>,./?";
+//   consectetur: i32 = 123456;
+//   adipiscing: boolean = false;
+//   elit: Array<i32> = [6,7,8,9,10];
+//   sed: f64 = F64.MAX_VALUE;
+//   eiusmod: string = "abcdYZ12345890./?";
+// }
+
+@json // 1 KB
+class ObjLarge {
+  lorum: u32 = U32.MAX_VALUE;
+  ipsum: boolean = true;
+  dolor: Array<i32> = [1,2,3,4,5];
+  sit: string = "abcdefghijklmnopdasfqrstfuvwYZ1234567890;~!@#$%^&*()_+=-{}][\\|;\":'<>,./?";
+  consectetur: i32 = 123456;
+  adipiscing: boolean = false;
+  elit: Array<i32> = [6,7,8,9,10];
+  sed: f64 = F64.MAX_VALUE;
+  eiusmod: string = "abcdYZ12345890./?abcdYZ12345890./?abcdYZ12340./?";
+  tempor: i32 = 999999;
+  incididunt: boolean = true;
+  ut: Array<i32> = [16,17,18,19,20];
+  labore: f64 = 3.1415926535;
+  et: string = "xyzXYZ09876!@#";
+  dolore: i32 = -123456;
+  magna: boolean = false;
+  aliqua: Array<i32> = [21,22,23,24,25];
+  argw: string = "abcdYZ12345890sdfw\"vie91kfESDFOK12i9i12dsf./?";
+}
+
+const obj = new ObjLarge();
+
+const arrSmall = new Array<i32>(25_600).fill(0);
+const arrMedium = new Array<i32>(128_000).fill(0);
+const arrLarge = new Array<i32>(256_000).fill(0); 
+
+const strSmall = "a".repeat(100 * 1024);
+const strMedium = "a".repeat(500 * 1024);
+const strLarge = "a".repeat(1024 * 1024);
+
+const arrSmallStr = JSON.stringify(arrSmall);
+const arrMediumStr = JSON.stringify(arrMedium);
+const arrLargeStr = JSON.stringify(arrLarge);
+
+const strSmallStr = JSON.stringify(strSmall);
+const strMediumStr = JSON.stringify(strMedium);
+const strLargeStr = JSON.stringify(strLarge);
+
+const objStr = JSON.stringify(obj); // `{"lorum":4294967295,"ipsum":true,"dolor":[1,2,3,4,5],"sit":"abcdefghijklmnopdasfqrstfuvwYZ1234567890;~!@#$%^&*()_+=-{}][\\\\|;\\":'<>,./?","consectetur":123456,"adipiscing":false,"elit":[6,7,8,9,10],"sed":1.7976931348623157e+308,"eiusmod":"abcdYZ12345890./?abcdYZ12345890./?abcdYZ12340./?","tempor":999999,"incididunt":true,"ut":[16,17,18,19,20],"labore":3.1415926535,"et":"xyzXYZ09876!@#","dolore":-123456,"magna":false,"aliqua":[21,22,23,24,25],"argw":"abcdYZ12345890sdfw\\"vie91kfESDFOK12i9i12dsf./?"}`;
+const objStrEnd = changetype<usize>(objStr) + (objStr.length << 1);
+
+console.log(objStr)
+expect(JSON.stringify(obj)).toBe(objStr);
+expect(JSON.stringify(JSON.parse<ObjLarge>(objStr))).toBe(objStr);
+const ITER = 2_000_000;
+
+/* --- OBJECTS --- */
+bench("Serialize Small Object", () => { // 1kb
+  // @ts-ignore
+  obj.__SERIALIZE(changetype<usize>(obj));
+  blackbox(bs.out<string>());
+}, 250_0000, objStr.length << 1);
+dumpToFile("small-obj", "serialize");
+
+// bench("Deserialize Small Object", () => {
+//     blackbox(JSON.parse<typeof objSmall>(objSmallStr))
+// }, ITER, objSmallStr.length << 1);
+// dumpToFile("small-obj", "deserialize");
+
+// bench("Serialize Medium Object", () => { // 500kb
+//   let ops = 500;
+//   while(ops > 0) {
+//   // @ts-ignore
+//   objLarge.__SERIALIZE(changetype<usize>(objLarge));
+//   ops--;
+//   }
+//   blackbox(bs.out<string>());
+// }, 5_000, (objLargeStr.length << 1) * 500);
+// dumpToFile("medium-obj", "serialize");
+
+// bench("Serialize Large Object", () => { // 500kb
+//   let ops = 1000;
+//   while(ops > 0) {
+//   // @ts-ignore
+//   objLarge.__SERIALIZE(changetype<usize>(objLarge));
+//   ops--;
+//   }
+//   blackbox(bs.out<string>());
+// }, 500, (objLargeStr.length << 1) * 1000);
+// dumpToFile("large-obj", "serialize");
+
+// bench("Deserialize Small Object", () => {
+//   // @ts-ignore
+//   objLarge.__DESERIALIZE<ObjLarge>(changetype<usize>(objLargeStr), objLargeStrEnd, changetype<ObjLarge>(__new(sizeof<ObjLarge>(), idof<ObjLarge>())));
+// }, 250_000, objLargeStr.length << 1);
+// dumpToFile("small-obj", "deserialize");
+
+// bench("Deserialize Medium Object", () => {
+//   let ops = 500;
+//   while (ops > 0) {
+//     // @ts-ignore
+//     objLarge.__DESERIALIZE<ObjLarge>(changetype<usize>(objLargeStr), objLargeStrEnd, changetype<ObjLarge>(__new(sizeof<ObjLarge>(), idof<ObjLarge>())));
+//     ops--;
+//   }
+// }, 5_000, (objLargeStr.length << 1) * 500);
+// dumpToFile("medium-obj", "deserialize");
+
+// bench("Deserialize Large Object", () => {
+//   let ops = 1000;
+//   while (ops > 0) {
+//     // @ts-ignore
+//     objLarge.__DESERIALIZE<ObjLarge>(changetype<usize>(objLargeStr), objLargeStrEnd, changetype<ObjLarge>(__new(sizeof<ObjLarge>(), idof<ObjLarge>())));
+//     ops--;
+//   }
+// }, 500, (objLargeStr.length << 1)*1000);
+// dumpToFile("large-obj", "deserialize");
+
+// // bench("Deserialize Medium Object", () => blackbox(JSON.parse<typeof objMedium>(objMediumStr)), ITER, objMediumStr.length << 1);
+// // dumpToFile("medium-obj", "deserialize");
+// // bench("Deserialize Large Object", () => blackbox(JSON.parse<typeof objLarge>(objLargeStr)), ITER, objLargeStr.length << 1);
+// // dumpToFile("large-obj", "deserialize");
+
+// /* --- ARRAYS --- */
+// bench("Serialize Small Array", () => blackbox(JSON.stringify(arrSmall)), ITER, arrSmallStr.length << 1);
+// dumpToFile("small-arr", "serialize");
+// bench("Deserialize Small Array", () => blackbox(JSON.parse<i32[]>(arrSmallStr)), ITER, arrSmallStr.length << 1);
+// dumpToFile("small-arr", "deserialize");
+
+// bench("Serialize Medium Array", () => blackbox(JSON.stringify(arrMedium)), ITER, arrMediumStr.length << 1);
+// dumpToFile("medium-arr", "serialize");
+// bench("Deserialize Medium Array", () => blackbox(JSON.parse<i32[]>(arrMediumStr)), ITER, arrMediumStr.length << 1);
+// dumpToFile("medium-arr", "deserialize");
+
+// bench("Serialize Large Array", () => blackbox(JSON.stringify(arrLarge)), ITER, arrLargeStr.length << 1);
+// dumpToFile("large-arr", "serialize");
+// bench("Deserialize Large Array", () => blackbox(JSON.parse<i32[]>(arrLargeStr)), ITER, arrLargeStr.length << 1);
+// dumpToFile("large-arr", "deserialize");
+
+// /* --- STRINGS --- */
+// bench("Serialize Small String", () => blackbox(JSON.stringify(strSmall)), ITER, strSmallStr.length << 1);
+// dumpToFile("small-str", "serialize");
+// bench("Deserialize Small String", () => blackbox(JSON.parse<string>(strSmallStr)), ITER, strSmallStr.length << 1);
+// dumpToFile("small-str", "deserialize");
+
+// bench("Serialize Medium String", () => blackbox(JSON.stringify(strMedium)), ITER, strMediumStr.length << 1);
+// dumpToFile("medium-str", "serialize");
+// bench("Deserialize Medium String", () => blackbox(JSON.parse<string>(strMediumStr)), ITER, strMediumStr.length << 1);
+// dumpToFile("medium-str", "deserialize");
+
+// bench("Serialize Large String", () => blackbox(JSON.stringify(strLarge)), ITER, strLargeStr.length << 1);
+// dumpToFile("large-str", "serialize");
+// bench("Deserialize Large String", () => blackbox(JSON.parse<string>(strLargeStr)), ITER, strLargeStr.length << 1);
+// dumpToFile("large-str", "deserialize");

package/assembly/__benches__/vec3.bench.ts

@@ -1,6 +1,6 @@
 import { JSON } from "..";
 import { expect } from "../__tests__/lib";
-import { bench } from "./lib/bench";
+import { bench, blackbox, dumpToFile } from "./lib/bench";
 
 
 @json
@@ -14,19 +14,24 @@ const v1: Vec3 = { x: 1, y: 2, z: 3 };
 const v2 = '{"x":1,"y":2,"z":3}';
 
 expect(JSON.stringify(v1)).toBe(v2);
+expect(JSON.stringify(JSON.parse<Vec3>(v2))).toBe(v2);
 
 bench(
   "Serialize Vec3",
   () => {
-    JSON.stringify(v1);
+    blackbox(inline.always(JSON.stringify(v1)));
   },
   128_000_00,
+  v2.length << 1
 );
+dumpToFile("vec3", "serialize")
 
 bench(
   "Deserialize Vec3",
   () => {
-    JSON.parse<Vec3>(v2);
+    blackbox(inline.always(JSON.parse<Vec3>(v2)));
   },
   128_000_00,
+  v2.length << 1
 );
+dumpToFile("vec3", "deserialize")

package/assembly/__tests__/string.spec.ts

@@ -11,6 +11,8 @@ describe("Should serialize strings", () => {
   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("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u000f\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f")).toBe('"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u000f\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f"');
+
+  expect(JSON.stringify("abcdYZ12345890sdfw\"vie91kfESDFOK12i9i12dsf./?")).toBe('"abcdYZ12345890sdfw\\"vie91kfESDFOK12i9i12dsf./?"');
 });
 
 describe("Should deserialize strings", () => {
@@ -23,4 +25,6 @@ describe("Should deserialize strings", () => {
   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 \\\\""');
 
   expect(JSON.parse<string>('"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u000f\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f"')).toBe("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u000f\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f");
+
+  expect(JSON.parse<string>('"abcdYZ12345890sdfw\\"vie91kfESDFOK12i9i12dsf./?"')).toBe("abcdYZ12345890sdfw\"vie91kfESDFOK12i9i12dsf./?");
 });

package/assembly/deserialize/simple/arbitrary.ts

@@ -5,11 +5,14 @@ import { deserializeFloat } from "./float";
 import { deserializeString } from "./string";
 import { deserializeObject } from "./object";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
+import { bs } from "../../../lib/as-bs";
+import { deserializeString_SWAR } from "../swar/string";
 
 export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
   const firstChar = load<u16>(srcStart);
-  if (firstChar == QUOTE) return JSON.Value.from(deserializeString(srcStart, srcEnd, 0));
-  else if (firstChar == BRACE_LEFT) return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
+  if (firstChar == QUOTE) {
+    return JSON.Value.from(deserializeString(srcStart, srcEnd, 0));
+  } else if (firstChar == BRACE_LEFT) return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
   else if (firstChar - 48 <= 9 || firstChar == 45) return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
   else if (firstChar == BRACKET_LEFT) {
     return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));

package/assembly/deserialize/simple/object.ts

@@ -1,7 +1,9 @@
 import { JSON } from "../..";
+import { bs } from "../../../lib/as-bs";
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
 import { isSpace } from "../../util";
 import { ptrToStr } from "../../util/ptrToStr";
+import { deserializeString_SWAR } from "../swar/string";
 import { deserializeArbitrary } from "./arbitrary";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
@@ -52,7 +54,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
           if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
-            // console.log("Value (string):-" + deserializeString(lastIndex, srcStart + 2, 0) + "-");
+            // console.log("Value (string):-" + deserializeString_SWAR(lastIndex, srcStart + 2, 0) + "-");
             out.set(ptrToStr(keyStart, keyEnd), deserializeString(lastIndex, srcStart + 2, 0));
             // while (isSpace(load<u16>(srcStart))) srcStart += 2;
             srcStart += 4;