json-as 1.3.6 → 1.3.8

package/assembly/deserialize/naive/float.ts

@@ -0,0 +1,135 @@
+import { ptrToStr } from "../../util/ptrToStr";
+import { isSpace } from "../../util";
+
+// Strict RFC 8259 number-grammar check over [srcStart, srcEnd) (surrounding
+// whitespace tolerated). Throws on any deviation: leading zeros, a bare `-`, a
+// fraction / exponent with no digits, a `+` sign, hex, Inf/NaN, or trailing
+// garbage. f64.parse alone is lenient (parses a numeric prefix and ignores the
+// rest), so this guard is what makes the naive value path reject malformed
+// numbers like `0e`, `-01`, `1.`, `2.e3`, `0x42`.
+// @ts-ignore: inline
+@inline function validateJSONNumber(srcStart: usize, srcEnd: usize): void {
+  let ptr = srcStart;
+  while (ptr < srcEnd && isSpace(load<u16>(ptr))) ptr += 2;
+  let end = srcEnd;
+  while (end > ptr && isSpace(load<u16>(end - 2))) end -= 2;
+  if (ptr >= end) throw new Error("Invalid JSON number: empty");
+
+  if (load<u16>(ptr) == 45) ptr += 2; // optional minus
+  if (ptr >= end) throw new Error("Invalid JSON number: bare '-'");
+
+  // Library extension (non-RFC, intentionally supported + tested): the literals
+  // NaN / Infinity / -Infinity. Hand these to f64.parse without strict checking.
+  const lead = load<u16>(ptr);
+  if (lead == 78 || lead == 110 || lead == 73 || lead == 105) return; // N n I i
+
+  // integer part: lone 0, or [1-9] digit*
+  const first = load<u16>(ptr);
+  if (first == 48) {
+    ptr += 2;
+    if (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9)
+      throw new Error("Invalid JSON number: leading zero");
+  } else if (<u32>(first - 48) <= 9) {
+    ptr += 2;
+    while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+  } else {
+    throw new Error("Invalid JSON number: expected digit");
+  }
+
+  // optional fraction: '.' digit+
+  if (ptr < end && load<u16>(ptr) == 46) {
+    ptr += 2;
+    if (ptr >= end || <u32>(load<u16>(ptr) - 48) > 9)
+      throw new Error("Invalid JSON number: fraction needs a digit");
+    while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+  }
+
+  // optional exponent: ('e'|'E') ['+'|'-'] digit+
+  if (ptr < end) {
+    const e = load<u16>(ptr);
+    if (e == 101 || e == 69) {
+      ptr += 2;
+      if (ptr < end) {
+        const sign = load<u16>(ptr);
+        if (sign == 43 || sign == 45) ptr += 2;
+      }
+      if (ptr >= end || <u32>(load<u16>(ptr) - 48) > 9)
+        throw new Error("Invalid JSON number: exponent needs a digit");
+      while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+    }
+  }
+
+  if (ptr != end) throw new Error("Invalid JSON number: trailing characters");
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat_NAIVE<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  validateJSONNumber(srcStart, srcEnd);
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return f64.parse(ptrToStr(srcStart, srcEnd));
+  // @ts-ignore
+  return f32.parse(ptrToStr(srcStart, srcEnd));
+}
+
+// @ts-ignore: inline
+@inline function scanFloatEnd(srcStart: usize, srcEnd: usize): usize {
+  let ptr = srcStart;
+  if (ptr < srcEnd && load<u16>(ptr) == 45) ptr += 2; // optional minus
+
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (<u32>code - 48 > 9) break;
+    ptr += 2;
+  }
+
+  if (ptr < srcEnd && load<u16>(ptr) == 46) {
+    ptr += 2;
+    while (ptr < srcEnd) {
+      const code = load<u16>(ptr);
+      if (<u32>code - 48 > 9) break;
+      ptr += 2;
+    }
+  }
+
+  if (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code == 101 || code == 69) {
+      ptr += 2;
+      if (ptr < srcEnd) {
+        const sign = load<u16>(ptr);
+        if (sign == 45 || sign == 43) ptr += 2;
+      }
+      while (ptr < srcEnd) {
+        const code = load<u16>(ptr);
+        if (<u32>code - 48 > 9) break;
+        ptr += 2;
+      }
+    }
+  }
+
+  return ptr;
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField_NAIVE<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const fieldPtr = dstObj + dstOffset;
+  const end = scanFloatEnd(srcStart, srcEnd);
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, f32.parse(ptrToStr(srcStart, end)));
+  } else {
+    store<f64>(fieldPtr, f64.parse(ptrToStr(srcStart, end)));
+  }
+
+  return end;
+}

package/assembly/deserialize/{simple → naive}/integer.ts

@@ -1,12 +1,20 @@
 import { atoi } from "../../util/atoi";
 
 // @ts-ignore: inline
-@inline export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
+@inline export function deserializeInteger_NAIVE<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
   return atoi<T>(srcStart, srcEnd);
 }
 
 // @ts-ignore: inline
-@inline export function deserializeIntegerField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+@inline export function deserializeIntegerField_NAIVE<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
   const fieldPtr = dstObj + dstOffset;
   let negative = false;
   if (load<u16>(srcStart) == 45) {

package/assembly/deserialize/{simple → naive}/map.ts

@@ -1,7 +1,19 @@
 import { JSON } from "../..";
-import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
+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, isUnescapedQuote, scanStringEnd } from "../../util";
-import { scanValueEnd } from "../swar/array/shared";
+import { scanValueEnd } from "../../util/scanValueEnd";
 
 // @ts-ignore: Decorator is valid here
 @inline function deserializeMapKey<T>(start: usize, end: usize): T {
@@ -10,8 +22,14 @@ import { scanValueEnd } from "../swar/array/shared";
   return JSON.parse<T>(keyText);
 }
 
-export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeMap<T extends Map<any, any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
 
   let keyStart: usize = 0;
   let keyEnd: usize = 0;
@@ -19,12 +37,20 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
   let depth = 0;
   let lastIndex: usize = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
-  if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
-  if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
-  if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+  if (srcStart - srcEnd == 0)
+    throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACE_LEFT)
+    throw new Error(
+      "Expected '{' at start of object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+  if (load<u16>(srcEnd - 2) != BRACE_RIGHT)
+    throw new Error(
+      "Expected '}' at end of object at position " +
+        (srcEnd - srcStart).toString(),
+    );
 
   srcStart += 2;
   while (srcStart < srcEnd) {
@@ -37,7 +63,11 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
           // console.log("Key: " + ptrToStr(lastIndex, srcStart));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
           while (isSpace((code = load<u16>((srcStart += 2))))) {}
-          if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
+          if (code !== COLON)
+            throw new Error(
+              "Expected ':' after key at position " +
+                (srcEnd - srcStart).toString(),
+            );
           isKey = false;
         } else {
           // console.log("Got key start");
@@ -51,9 +81,13 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
       if (code == QUOTE) {
         lastIndex = srcStart;
         srcStart = scanStringEnd(srcStart, srcEnd);
-        if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
+        if (srcStart >= srcEnd)
+          throw new Error("Unterminated string in JSON object");
         // @ts-ignore: type
-        out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2));
+        out.set(
+          deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+          JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2),
+        );
         srcStart += 2;
         keyStart = 0;
         continue;
@@ -65,7 +99,10 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
           if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
             // @ts-ignore: type
-            out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            out.set(
+              deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+              JSON.__deserialize<valueof<T>>(lastIndex, srcStart),
+            );
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -84,12 +121,16 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
           const code = load<u16>(srcStart);
           if (code == QUOTE) {
             srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
+            if (srcStart >= srcEnd)
+              throw new Error("Unterminated string in JSON object");
           } else if (code == BRACE_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              out.set(
+                deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+                JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)),
+              );
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -108,12 +149,16 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
           const code = load<u16>(srcStart);
           if (code == QUOTE) {
             srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
+            if (srcStart >= srcEnd)
+              throw new Error("Unterminated string in JSON object");
           } else if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              out.set(
+                deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+                JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)),
+              );
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -128,7 +173,10 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart) == 28429475166421108) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          out.set(
+            deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+            JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)),
+          );
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -140,7 +188,10 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart, 2) == 28429466576093281) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
           // @ts-ignore: type
-          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
+          out.set(
+            deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+            JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)),
+          );
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -152,7 +203,10 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart) == 30399761348886638) {
           // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          out.set(
+            deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+            JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)),
+          );
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }
@@ -163,7 +217,12 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
       } else if (isSpace(code)) {
         srcStart += 2;
       } else {
-        throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString());
+        throw new Error(
+          "Unexpected character in JSON object '" +
+            String.fromCharCode(code) +
+            "' at position " +
+            (srcEnd - srcStart).toString(),
+        );
       }
     }
   }
@@ -171,15 +230,22 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
 }
 
 
-@inline export function deserializeMapInto<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function deserializeMapBody<T extends Map<any, any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   changetype<nonnull<T>>(out).clear();
 
-  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACE_LEFT) throw new Error("Failed to parse JSON!");
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACE_LEFT)
+    throw new Error("Failed to parse JSON!");
   srcStart += 2;
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   if (srcStart >= srcEnd) throw new Error("Failed to parse JSON!");
   if (load<u16>(srcStart) == BRACE_RIGHT) return srcStart + 2;
 
   while (srcStart < srcEnd) {
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (load<u16>(srcStart) != QUOTE) break;
 
     const keyStart = srcStart + 2;
@@ -187,20 +253,27 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
     if (keyEnd >= srcEnd) break;
 
     srcStart = keyEnd + 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd || load<u16>(srcStart) != COLON) break;
     srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
 
     const valueEnd = scanValueEnd(srcStart, srcEnd);
     if (!valueEnd || valueEnd <= srcStart) break;
 
     // @ts-ignore: type
-    changetype<nonnull<T>>(out).set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
+    changetype<nonnull<T>>(out).set(
+      deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+      JSON.__deserialize<valueof<T>>(srcStart, valueEnd),
+    );
     srcStart = valueEnd;
 
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
     const code = load<u16>(srcStart);
     if (code == COMMA) {
       srcStart += 2;
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
       continue;
     }
     if (code == BRACE_RIGHT) return srcStart + 2;
@@ -211,11 +284,17 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
 }
 
 
-@inline export function deserializeMapField<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
-  let out = load<T>(dstObj, dstOffset);
+@inline export function deserializeMapField<T extends Map<any, any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const fieldPtr = dstObj + dstOffset;
+  let out = load<T>(fieldPtr);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
-    store<T>(dstObj, out, dstOffset);
+    store<T>(fieldPtr, out);
   }
-  return deserializeMapInto<T>(srcStart, srcEnd, out);
+  return deserializeMapBody<T>(srcStart, srcEnd, out);
 }

package/assembly/deserialize/{simple → naive}/object.ts

@@ -1,16 +1,30 @@
 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 {
+  BACK_SLASH,
+  COMMA,
+  CHAR_F,
+  BRACE_LEFT,
+  BRACKET_LEFT,
+  CHAR_N,
+  QUOTE,
+  BRACE_RIGHT,
+  BRACKET_RIGHT,
+  CHAR_T,
+  COLON,
+} from "../../custom/chars";
 import { isSpace, isUnescapedQuote, scanStringEnd } 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";
-import { deserializeFloat } from "./float";
-import { deserializeString } from "./string";
+import { deserializeFloat_NAIVE } from "./float";
+import { deserializeString_NAIVE } from "./string";
 
-export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): JSON.Obj {
+export function deserializeObject(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Obj {
   const out = changetype<JSON.Obj>(dst || changetype<usize>(new JSON.Obj()));
 
   let keyStart: usize = 0;
@@ -19,12 +33,20 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
   let depth = 0;
   let lastIndex: usize = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
-  if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
-  if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
-  if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+  if (srcStart - srcEnd == 0)
+    throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACE_LEFT)
+    throw new Error(
+      "Expected '{' at start of object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+  if (load<u16>(srcEnd - 2) != BRACE_RIGHT)
+    throw new Error(
+      "Expected '}' at end of object at position " +
+        (srcEnd - srcStart).toString(),
+    );
 
   srcStart += 2;
   while (srcStart < srcEnd) {
@@ -37,7 +59,11 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           // console.log("Key: " + ptrToStr(lastIndex, srcStart));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
           while (isSpace((code = load<u16>((srcStart += 2))))) {}
-          if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
+          if (code !== COLON)
+            throw new Error(
+              "Expected ':' after key at position " +
+                (srcEnd - srcStart).toString(),
+            );
           isKey = false;
         } else {
           // console.log("Got key start");
@@ -51,8 +77,12 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       if (code == QUOTE) {
         lastIndex = srcStart;
         srcStart = scanStringEnd(srcStart, srcEnd);
-        if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
-        out.set(ptrToStr(keyStart, keyEnd), deserializeString(lastIndex, srcStart + 2));
+        if (srcStart >= srcEnd)
+          throw new Error("Unterminated string in JSON object");
+        out.set(
+          ptrToStr(keyStart, keyEnd),
+          deserializeString_NAIVE(lastIndex, srcStart + 2),
+        );
         srcStart += 2;
         keyStart = 0;
         continue;
@@ -63,7 +93,10 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           const code = load<u16>(srcStart);
           if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-            out.set(ptrToStr(keyStart, keyEnd), deserializeFloat<f64>(lastIndex, srcStart));
+            out.set(
+              ptrToStr(keyStart, keyEnd),
+              deserializeFloat_NAIVE<f64>(lastIndex, srcStart),
+            );
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -82,11 +115,15 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           const code = load<u16>(srcStart);
           if (code == QUOTE) {
             srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
+            if (srcStart >= srcEnd)
+              throw new Error("Unterminated string in JSON object");
           } else if (code == BRACE_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(ptrToStr(keyStart, keyEnd), deserializeObject(lastIndex, (srcStart += 2), 0));
+              out.set(
+                ptrToStr(keyStart, keyEnd),
+                deserializeObject(lastIndex, (srcStart += 2), 0),
+              );
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -105,11 +142,15 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           const code = load<u16>(srcStart);
           if (code == QUOTE) {
             srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
+            if (srcStart >= srcEnd)
+              throw new Error("Unterminated string in JSON object");
           } else if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(ptrToStr(keyStart, keyEnd), deserializeArray<JSON.Value[]>(lastIndex, (srcStart += 2), 0));
+              out.set(
+                ptrToStr(keyStart, keyEnd),
+                deserializeArray<JSON.Value[]>(lastIndex, (srcStart += 2), 0),
+              );
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -159,7 +200,12 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       } else if (isSpace(code)) {
         srcStart += 2;
       } else {
-        throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString());
+        throw new Error(
+          "Unexpected character in JSON object '" +
+            String.fromCharCode(code) +
+            "' at position " +
+            (srcEnd - srcStart).toString(),
+        );
       }
     }
   }

package/assembly/deserialize/{simple → naive}/raw.ts

@@ -2,6 +2,9 @@ import { JSON } from "../..";
 import { ptrToStr } from "../../util/ptrToStr";
 
 // @ts-ignore: inline
-@inline export function deserializeRaw(srcStart: usize, srcEnd: usize): JSON.Raw {
+@inline export function deserializeRaw(
+  srcStart: usize,
+  srcEnd: usize,
+): JSON.Raw {
   return JSON.Raw.from(ptrToStr(srcStart, srcEnd));
 }