json-as 1.3.8 → 1.4.0

package/assembly/deserialize/naive/map.ts

@@ -1,19 +1,14 @@
 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 { isSpace, isUnescapedQuote, scanStringEnd } from "../../util";
+import { isSpace, scanStringEnd } from "../../util";
 import { scanValueEnd } from "../../util/scanValueEnd";
+import { lastValueEnd, parseValue } from "./object";
 
 // @ts-ignore: Decorator is valid here
 @inline function deserializeMapKey<T>(start: usize, end: usize): T {
@@ -31,13 +26,7 @@ export function deserializeMap<T extends Map<any, any>>(
     dst || changetype<usize>(instantiate<T>()),
   );
 
-  let keyStart: usize = 0;
-  let keyEnd: usize = 0;
-  let isKey = false;
-  let depth = 0;
-  let lastIndex: usize = 0;
-
-  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
   if (srcStart - srcEnd == 0)
     throw new Error("Input string had zero length or was all whitespace");
@@ -52,190 +41,26 @@ export function deserializeMap<T extends Map<any, any>>(
         (srcEnd - srcStart).toString(),
     );
 
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
-    if (keyStart == 0) {
-      if (code == QUOTE && isUnescapedQuote(srcStart)) {
-        if (isKey) {
-          keyStart = lastIndex;
-          keyEnd = srcStart;
-          // 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(),
-            );
-          isKey = false;
-        } else {
-          // console.log("Got key start");
-          isKey = true; // i don't like this
-          lastIndex = srcStart + 2;
-        }
-      }
-      // isKey = !isKey;
-      srcStart += 2;
-    } else {
-      if (code == QUOTE) {
-        lastIndex = srcStart;
-        srcStart = scanStringEnd(srcStart, srcEnd);
-        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),
-        );
-        srcStart += 2;
-        keyStart = 0;
-        continue;
-      } else if (code - 48 <= 9 || code == 45) {
-        lastIndex = srcStart;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const code = load<u16>(srcStart);
-          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),
-            );
-            // while (isSpace(load<u16>((srcStart += 2)))) {
-            //   /* empty */
-            // }
-            srcStart += 2;
-            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-            keyStart = 0;
-            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 = scanStringEnd(srcStart, srcEnd);
-            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)),
-              );
-              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-              keyStart = 0;
-              // while (isSpace(load<u16>(srcStart))) {
-              //   /* empty */
-              // }
-              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 = scanStringEnd(srcStart, srcEnd);
-            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)),
-              );
-              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-              keyStart = 0;
-              // while (isSpace(load<u16>((srcStart += 2)))) {
-              //   /* empty */
-              // }
-              break;
-            }
-          } else if (code == BRACKET_LEFT) depth++;
-          srcStart += 2;
-        }
-      } else if (code == CHAR_T) {
-        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)),
-          );
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)) + "  " + (srcStart < srcEnd).toString());
-          keyStart = 0;
-        }
-      } else if (code == CHAR_F) {
-        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)),
-          );
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-          keyStart = 0;
-        }
-      } else if (code == CHAR_N) {
-        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)),
-          );
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-          keyStart = 0;
-        }
-      } else if (isSpace(code)) {
-        srcStart += 2;
-      } else {
-        throw new Error(
-          "Unexpected character in JSON object '" +
-            String.fromCharCode(code) +
-            "' at position " +
-            (srcEnd - srcStart).toString(),
-        );
-      }
-    }
-  }
-  return out;
+  deserializeMapBody<T>(srcStart, srcEnd, changetype<T>(out));
+  return changetype<T>(out);
 }
 
-
-@inline function deserializeMapBody<T extends Map<any, any>>(
+/**
+ * Shared single-pass map-body parser used by both the top-level and struct-field
+ * entry points. Dynamic `JSON.Value` values are parsed in one pass via
+ * {@link parseValue}; typed values are bounds-scanned with {@link scanValueEnd}
+ * because their generated deserializers take exact `(start, end)` bounds.
+ */
+export function deserializeMapBody<T extends Map<any, any>>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
 ): usize {
-  changetype<nonnull<T>>(out).clear();
+  let arbitraryValue = false;
+  if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+    // @ts-ignore: instanceof on the (reference) value type
+    arbitraryValue = changetype<nonnull<valueof<T>>>(0) instanceof JSON.Value;
+  }
 
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACE_LEFT)
     throw new Error("Failed to parse JSON!");
@@ -258,15 +83,24 @@ export function deserializeMap<T extends Map<any, any>>(
     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),
-    );
-    srcStart = valueEnd;
+    if (isReference<valueof<T>>() && arbitraryValue) {
+      const val = parseValue(srcStart, srcEnd);
+      // @ts-ignore: type — valueof<T> is JSON.Value in this branch
+      changetype<nonnull<T>>(out).set(
+        deserializeMapKey<indexof<T>>(keyStart, keyEnd),
+        changetype<valueof<T>>(changetype<usize>(val)),
+      );
+      srcStart = lastValueEnd();
+    } else {
+      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),
+      );
+      srcStart = valueEnd;
+    }
 
     while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
@@ -283,7 +117,7 @@ export function deserializeMap<T extends Map<any, any>>(
   throw new Error("Failed to parse JSON!");
 }
 
-
+// @ts-ignore: Decorator is valid here
 @inline export function deserializeMapField<T extends Map<any, any>>(
   srcStart: usize,
   srcEnd: usize,
@@ -295,6 +129,10 @@ export function deserializeMap<T extends Map<any, any>>(
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
     store<T>(fieldPtr, out);
+  } else {
+    // Reusing an existing field map — clear it before repopulating. Fresh maps
+    // (deserializeMap / deserializeMapArray) skip this.
+    changetype<nonnull<T>>(out).clear();
   }
   return deserializeMapBody<T>(srcStart, srcEnd, out);
 }

package/assembly/deserialize/naive/object.ts

@@ -1,7 +1,5 @@
 import { JSON } from "../..";
-import { bs } from "../../../lib/as-bs";
 import {
-  BACK_SLASH,
   COMMA,
   CHAR_F,
   BRACE_LEFT,
@@ -13,12 +11,26 @@ import {
   CHAR_T,
   COLON,
 } from "../../custom/chars";
-import { isSpace, isUnescapedQuote, scanStringEnd } from "../../util";
-import { ptrToStr } from "../../util/ptrToStr";
-import { deserializeArray } from "./array";
-import { deserializeBoolean } from "./bool";
-import { deserializeFloat_NAIVE } from "./float";
-import { deserializeString_NAIVE } from "./string";
+import { isSpace, scanStringEnd } from "../../util";
+import { deserializeFloat } from "../index/float";
+import { deserializeString } from "../index/string";
+
+// "true"  as a u64 of UTF-16 code units (LE).
+// @ts-ignore: inline
+@inline const TRUE_WORD: u64 = 28429475166421108;
+// "alse"  — the tail of "false", read at +2 so the leading 'f' is skipped.
+// @ts-ignore: inline
+@inline const ALSE_WORD: u64 = 28429466576093281;
+// "null"  as a u64 of UTF-16 code units (LE).
+// @ts-ignore: inline
+@inline const NULL_WORD: u64 = 30399761348886638;
+
+// End offset (just past the value) of the most recent parseValue() call. The
+// recursive-descent parser reports each value's end through this single cursor
+// so containers can resume after a child without a separate bounds scan. It is
+// only read immediately after parseValue() returns, before any other
+// parseValue() runs, so recursion never clobbers a still-needed value.
+let parseValueEnd: usize = 0;
 
 export function deserializeObject(
   srcStart: usize,
@@ -27,15 +39,9 @@ export function deserializeObject(
 ): JSON.Obj {
   const out = changetype<JSON.Obj>(dst || changetype<usize>(new JSON.Obj()));
 
-  let keyStart: usize = 0;
-  let keyEnd: usize = 0;
-  let isKey = false;
-  let depth = 0;
-  let lastIndex: usize = 0;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
-  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
-
-  if (srcStart - srcEnd == 0)
+  if (srcEnd == srcStart)
     throw new Error("Input string had zero length or was all whitespace");
   if (load<u16>(srcStart) != BRACE_LEFT)
     throw new Error(
@@ -48,166 +54,139 @@ export function deserializeObject(
         (srcEnd - srcStart).toString(),
     );
 
-  srcStart += 2;
+  parseObjectBody(out, srcStart + 2, srcEnd);
+  return out;
+}
+
+/**
+ * Parses a single JSON value whose first character is at `srcStart` (`srcEnd`
+ * is an upper bound). Returns the value and sets {@link parseValueEnd} to the
+ * offset just after it. Nested objects and arrays recurse here, so every byte
+ * is scanned exactly once.
+ */
+/** Offset just past the value returned by the most recent {@link parseValue}. */
+export function lastValueEnd(): usize {
+  return parseValueEnd;
+}
+
+export function parseValue(srcStart: usize, srcEnd: usize): JSON.Value {
+  const code = load<u16>(srcStart);
+  if (code == QUOTE) {
+    const end = scanStringEnd(srcStart, srcEnd);
+    if (end >= srcEnd) throw new Error("Unterminated string in JSON");
+    parseValueEnd = end + 2;
+    return JSON.Value.from(deserializeString(srcStart, end + 2));
+  } else if (code == BRACE_LEFT) {
+    const obj = new JSON.Obj();
+    parseValueEnd = parseObjectBody(obj, srcStart + 2, srcEnd);
+    return JSON.Value.from(obj);
+  } else if (code == BRACKET_LEFT) {
+    const arr = instantiate<JSON.Value[]>();
+    parseValueEnd = parseArrayBody(arr, srcStart + 2, srcEnd);
+    return JSON.Value.from(arr);
+  } else if (code - 48 <= 9 || code == 45) {
+    let p = srcStart + 2;
+    while (p < srcEnd) {
+      const c = load<u16>(p);
+      if (c == COMMA || c == BRACKET_RIGHT || c == BRACE_RIGHT || isSpace(c))
+        break;
+      p += 2;
+    }
+    parseValueEnd = p;
+    return JSON.Value.from(deserializeFloat<f64>(srcStart, p));
+  } else if (code == CHAR_T) {
+    if (load<u64>(srcStart) != TRUE_WORD)
+      throw new Error("Expected 'true' in JSON");
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.from(true);
+  } else if (code == CHAR_F) {
+    if (load<u64>(srcStart, 2) != ALSE_WORD)
+      throw new Error("Expected 'false' in JSON");
+    parseValueEnd = srcStart + 10;
+    return JSON.Value.from(false);
+  } else if (code == CHAR_N) {
+    if (load<u64>(srcStart) != NULL_WORD)
+      throw new Error("Expected 'null' in JSON");
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.from<usize>(0);
+  }
+  throw new Error(
+    "Unexpected character in JSON '" + String.fromCharCode(code) + "'",
+  );
+}
+
+/**
+ * Parses array elements starting at `srcStart` (just past the opening `[`)
+ * until the matching `]`, returning the offset just after that `]`. Nested
+ * values are parsed in the same pass.
+ */
+export function parseArrayBody(
+  out: JSON.Value[],
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
   while (srcStart < srcEnd) {
-    let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
-    if (keyStart == 0) {
-      if (code == QUOTE && isUnescapedQuote(srcStart)) {
-        if (isKey) {
-          keyStart = lastIndex;
-          keyEnd = srcStart;
-          // 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(),
-            );
-          isKey = false;
-        } else {
-          // console.log("Got key start");
-          isKey = true; // i don't like this
-          lastIndex = srcStart + 2;
-        }
-      }
-      // isKey = !isKey;
+    const code = load<u16>(srcStart);
+    if (isSpace(code) || code == COMMA) {
       srcStart += 2;
-    } else {
-      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_NAIVE(lastIndex, srcStart + 2),
-        );
-        srcStart += 2;
-        keyStart = 0;
-        continue;
-      } else if (code - 48 <= 9 || code == 45) {
-        lastIndex = srcStart;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          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_NAIVE<f64>(lastIndex, srcStart),
-            );
-            // while (isSpace(load<u16>((srcStart += 2)))) {
-            //   /* empty */
-            // }
-            srcStart += 2;
-            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-            keyStart = 0;
-            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 = scanStringEnd(srcStart, srcEnd);
-            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),
-              );
-              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-              keyStart = 0;
-              // while (isSpace(load<u16>(srcStart))) {
-              //   /* empty */
-              // }
-              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 = scanStringEnd(srcStart, srcEnd);
-            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),
-              );
-              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-              keyStart = 0;
-              // while (isSpace(load<u16>((srcStart += 2)))) {
-              //   /* empty */
-              // }
-              break;
-            }
-          } else if (code == BRACKET_LEFT) depth++;
-          srcStart += 2;
-        }
-      } else if (code == CHAR_T) {
-        if (load<u64>(srcStart) == 28429475166421108) {
-          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), true);
-          srcStart += 8;
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)) + "  " + (srcStart < srcEnd).toString());
-          keyStart = 0;
-        }
-      } else if (code == CHAR_F) {
-        if (load<u64>(srcStart, 2) == 28429466576093281) {
-          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
-          out.set(ptrToStr(keyStart, keyEnd), false);
-          srcStart += 10;
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-          keyStart = 0;
-        }
-      } else if (code == CHAR_N) {
-        if (load<u64>(srcStart) == 30399761348886638) {
-          // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), JSON.Value.from<usize>(0));
-          srcStart += 8;
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-          keyStart = 0;
-        }
-      } else if (isSpace(code)) {
-        srcStart += 2;
-      } else {
-        throw new Error(
-          "Unexpected character in JSON object '" +
-            String.fromCharCode(code) +
-            "' at position " +
-            (srcEnd - srcStart).toString(),
-        );
-      }
+      continue;
     }
+    if (code == BRACKET_RIGHT) return srcStart + 2;
+    out.push(parseValue(srcStart, srcEnd));
+    srcStart = parseValueEnd;
   }
-  return out;
+  return srcEnd;
+}
+
+/**
+ * Parses object members starting at `srcStart` (just past the opening `{`)
+ * until the matching `}`, returning the offset just after that `}`. `srcEnd`
+ * is an upper bound (end of the enclosing buffer), not the object's exact end.
+ */
+export function parseObjectBody(
+  out: JSON.Obj,
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart);
+
+    // Skip insignificant whitespace and member separators before each key.
+    if (isSpace(code) || code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACE_RIGHT) return srcStart + 2;
+
+    // --- key ---
+    if (code != QUOTE)
+      throw new Error(
+        "Unexpected character in JSON object '" +
+          String.fromCharCode(code) +
+          "' at position " +
+          (srcEnd - srcStart).toString(),
+      );
+    const keyStart = srcStart + 2;
+    srcStart = scanStringEnd(srcStart, srcEnd);
+    if (srcStart >= srcEnd)
+      throw new Error("Unterminated string in JSON object");
+    const keyEnd = srcStart;
+    srcStart += 2;
+
+    // --- colon ---
+    while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
+      srcStart += 2;
+    if (srcStart >= srcEnd || code != COLON)
+      throw new Error(
+        "Expected ':' after key at position " + (srcEnd - srcStart).toString(),
+      );
+    srcStart += 2;
+
+    // --- value ---
+    while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
+      srcStart += 2;
+    out.appendRaw(keyStart, keyEnd, parseValue(srcStart, srcEnd));
+    srcStart = parseValueEnd;
+  }
+  return srcEnd;
 }

package/assembly/deserialize/naive/set.ts

@@ -11,8 +11,7 @@ import {
 } from "../../custom/chars";
 import { isSpace, atoi, scanStringEnd } from "../../util";
 
-// @ts-expect-error: Decorator valid here
-@inline function scanSetElementEnd(srcStart: usize, srcEnd: usize): usize {
+function scanSetElementEnd(srcStart: usize, srcEnd: usize): usize {
   const first = load<u16>(srcStart);
 
   if (first == QUOTE) {

package/assembly/deserialize/naive/staticarray.ts

@@ -17,8 +17,7 @@ import { deserializeStaticArrayInteger } from "./staticarray/integer";
 import { deserializeStaticArrayString } from "./staticarray/string";
 import { scanValueEnd } from "../../util/scanValueEnd";
 
-
-@inline function materializeStaticArray<T extends StaticArray<any>>(
+function materializeStaticArray<T extends StaticArray<any>>(
   src: valueof<T>[],
   dst: usize,
 ): T {