json-as 1.3.9 → 1.5.0

package/assembly/deserialize/index/integer.ts

@@ -21,8 +21,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeInteger<T extends number>(
+export function deserializeInteger<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -46,8 +45,7 @@ import {
  * @param dstOffset Byte offset of the field within `dstObj`.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeIntegerField<T extends number>(
+export function deserializeIntegerField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/index/object.ts

@@ -1 +1,6 @@
-export { deserializeObject } from "../naive/object";
+export {
+  deserializeObject,
+  deserializeJsonArray,
+  setParseSrc,
+  getParseSrc,
+} from "../naive/object";

package/assembly/deserialize/index/string.ts

@@ -12,11 +12,7 @@ import {
   deserializeStringField_SWAR,
 } from "../swar/string";
 
-
-@inline export function deserializeString(
-  srcStart: usize,
-  srcEnd: usize,
-): string {
+export function deserializeString(srcStart: usize, srcEnd: usize): string {
   if (JSON_MODE == JSONMode.SIMD) {
     return deserializeString_SIMD(srcStart, srcEnd);
   } else if (JSON_MODE == JSONMode.NAIVE) {
@@ -26,8 +22,7 @@ import {
   }
 }
 
-
-@inline export function deserializeStringField<T extends string | null>(
+export function deserializeStringField<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/index/unsigned.ts

@@ -21,8 +21,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeUnsigned<T extends number>(
+export function deserializeUnsigned<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -46,8 +45,7 @@ import {
  * @param dstOffset Byte offset of the field within `dstObj`.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeUnsignedField<T extends number>(
+export function deserializeUnsignedField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/naive/array/arbitrary.ts

@@ -1,18 +1,5 @@
-import {
-  BACK_SLASH,
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-  CHAR_F,
-  CHAR_N,
-  CHAR_T,
-  COMMA,
-  QUOTE,
-} from "../../../custom/chars";
 import { JSON } from "../../../";
-import { isSpace, scanStringEnd } from "../../../util";
-import { ptrToStr } from "../../../util/ptrToStr";
+import { parseArrayBody } from "../object";
 
 export function deserializeArbitraryArray(
   srcStart: usize,
@@ -22,127 +9,7 @@ export function deserializeArbitraryArray(
   const out = changetype<JSON.Value[]>(
     dst || changetype<usize>(instantiate<JSON.Value[]>()),
   );
-  let lastIndex: usize = 0;
-  let depth: u32 = 0;
-  // if (load<u16>(srcStart) != BRACKET_LEFT)
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    const code = load<u16>(srcStart);
-    // console.log("code: " + String.fromCharCode(code));
-    if (code == BRACE_LEFT) {
-      lastIndex = srcStart;
-      depth++;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == BRACE_RIGHT) {
-          if (--depth == 0) {
-            // @ts-ignore: type
-            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-            break;
-          }
-        } else if (code == BRACE_LEFT) depth++;
-        srcStart += 2;
-      }
-    } else if (code == QUOTE) {
-      lastIndex = srcStart;
-      srcStart = scanStringEnd(srcStart, srcEnd);
-      if (srcStart >= srcEnd)
-        throw new Error("Unterminated string in JSON array");
-      // @ts-ignore: exists
-      out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-      srcStart += 2;
-      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-    } else if (code - 48 <= 9 || code == 45) {
-      // console.log("trigger int")
-      lastIndex = srcStart;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
-          // @ts-ignore: type
-          out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
-          // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-          break;
-        }
-        srcStart += 2;
-      }
-      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-    } else if (code == BRACE_LEFT) {
-      lastIndex = srcStart;
-      depth++;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == BRACE_RIGHT) {
-          if (--depth == 0) {
-            // @ts-ignore: type
-            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-            while (isSpace(load<u16>((srcStart += 2)))) {
-              /* 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 array");
-        } else if (code == BRACKET_RIGHT) {
-          if (--depth == 0) {
-            // @ts-ignore: type
-            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-            // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-            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) {
-        // @ts-ignore: type
-        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
-        // console.log("Value (bool): " + ptrToStr(srcStart - 8, srcStart));
-        // while (isSpace(load<u16>((srcStart += 2)))) {
-        //   /* empty */
-        // }
-        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-      }
-    } else if (code == CHAR_F) {
-      if (load<u64>(srcStart, 2) == 28429466576093281) {
-        // @ts-ignore: type
-        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 10)));
-        // console.log("Value (bool): " + ptrToStr(srcStart - 10, srcStart));
-        // while (isSpace(load<u16>((srcStart += 2)))) {
-        //   /* empty */
-        // }
-        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-      }
-    } else if (code == CHAR_N) {
-      if (load<u64>(srcStart) == 30399761348886638) {
-        // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-        // @ts-ignore: type
-        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
-        // while (isSpace(load<u16>((srcStart += 2)))) {
-        //   /* empty */
-        // }
-      }
-    }
-    srcStart += 2;
-  }
-  // @ts-ignore: type
+  // Skip the opening '[' and parse elements single-pass until the matching ']'.
+  parseArrayBody(out, srcStart + 2, srcEnd);
   return out;
 }

package/assembly/deserialize/naive/array/array.ts

@@ -1,5 +1,6 @@
 import { BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../../";
+import { parseArrayBody } from "../object";
 
 export function deserializeArrayArray<T extends unknown[][]>(
   srcStart: usize,
@@ -9,9 +10,37 @@ export function deserializeArrayArray<T extends unknown[][]>(
   const out = changetype<nonnull<T>>(
     dst || changetype<usize>(instantiate<T>()),
   );
+
+  // Compile-time: is each inner array a dynamic JSON.Value[] (vs a typed array)?
+  let arbitraryInner = false;
+  if (isManaged<valueof<valueof<T>>>() || isReference<valueof<valueof<T>>>()) {
+    // @ts-ignore: instanceof on the (reference) inner element type
+    arbitraryInner =
+      changetype<nonnull<valueof<valueof<T>>>>(0) instanceof JSON.Value;
+  }
+
+  srcStart += 2; // skip the outer '['
+
+  if (isReference<valueof<valueof<T>>>() && arbitraryInner) {
+    // Single-pass: each inner `[...]` is a JSON.Value[] parsed in one scan
+    // (this also correctly skips ']' inside strings, unlike the depth scan).
+    while (srcStart < srcEnd) {
+      if (load<u16>(srcStart) == BRACKET_LEFT) {
+        const inner = instantiate<JSON.Value[]>();
+        srcStart = parseArrayBody(inner, srcStart + 2, srcEnd);
+        // @ts-ignore: valueof<T> is JSON.Value[] in this branch
+        out.push(changetype<valueof<T>>(changetype<usize>(inner)));
+      } else {
+        srcStart += 2;
+      }
+    }
+    return out;
+  }
+
+  // Typed inner arrays: scan each element's bounds, then hand the exact range
+  // to its generated (bounds-taking) deserializer.
   let lastIndex: usize = 0;
   let depth: u32 = 0;
-  srcStart += 2;
   while (srcStart < srcEnd - 2) {
     const code = load<u16>(srcStart);
     if (code == BRACKET_LEFT && depth++ == 0) {

package/assembly/deserialize/naive/array/integer.ts

@@ -2,14 +2,9 @@ import { atoi, isSpace } from "../../../util";
 import { COMMA, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 
 // Strict RFC 8259 integer-token check over [start, end): optional minus (signed
-// types only), then a lone `0` or [1-9] digits — no leading zeros, fraction,
+// types only), then a lone `0` or [1-9] digits - no leading zeros, fraction,
 // exponent, or trailing garbage. Throws otherwise.
-// @ts-ignore: inline
-@inline function validateJSONInteger(
-  start: usize,
-  end: usize,
-  signed: bool,
-): void {
+function validateJSONInteger(start: usize, end: usize, signed: bool): void {
   let ptr = start;
   if (ptr < end && load<u16>(ptr) == 45) {
     if (!signed) throw new Error("Invalid JSON number: minus on unsigned");

package/assembly/deserialize/naive/array/map.ts

@@ -1,11 +1,7 @@
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-} from "../../../custom/chars";
+import { BRACE_LEFT, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 import { isSpace } from "util/string";
+import { deserializeMapBody } from "../map";
 
 export function deserializeMapArray<T extends Map<any, any>[]>(
   srcStart: usize,
@@ -15,8 +11,6 @@ export function deserializeMapArray<T extends Map<any, any>[]>(
   const out = changetype<nonnull<T>>(
     dst || changetype<usize>(instantiate<T>()),
   );
-  let lastIndex: usize = 0;
-  let depth: u32 = 0;
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
@@ -34,14 +28,16 @@ export function deserializeMapArray<T extends Map<any, any>[]>(
         (srcEnd - srcStart).toString(),
     );
 
+  // Each `{...}` map element is parsed in a single pass via deserializeMapBody,
+  // which reports where it ended - no separate scan to find the closing brace.
   while (srcStart < srcEnd) {
-    const code = load<u16>(srcStart);
-    if (code == BRACE_LEFT && depth++ == 0) {
-      lastIndex = srcStart;
-    } else if (code == BRACE_RIGHT && --depth == 0) {
-      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+    if (load<u16>(srcStart) == BRACE_LEFT) {
+      const m = instantiate<valueof<T>>();
+      srcStart = deserializeMapBody<valueof<T>>(srcStart, srcEnd, m);
+      out.push(m);
+    } else {
+      srcStart += 2;
     }
-    srcStart += 2;
   }
   return out;
 }

package/assembly/deserialize/naive/array/object.ts

@@ -1,11 +1,7 @@
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-} from "../../../custom/chars";
+import { BRACE_LEFT, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 import { isSpace } from "util/string";
+import { parseObjectBody } from "../object";
 
 export function deserializeObjectArray<T extends unknown[]>(
   srcStart: usize,
@@ -15,8 +11,6 @@ export function deserializeObjectArray<T extends unknown[]>(
   const out = changetype<nonnull<T>>(
     dst || changetype<usize>(instantiate<T>()),
   );
-  let lastIndex: usize = 0;
-  let depth: u32 = 0;
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
@@ -34,14 +28,16 @@ export function deserializeObjectArray<T extends unknown[]>(
         (srcEnd - srcStart).toString(),
     );
 
+  // Each `{...}` element is parsed in a single pass via parseObjectBody, which
+  // reports where it ended - no separate scan to find the closing brace.
   while (srcStart < srcEnd) {
-    const code = load<u16>(srcStart);
-    if (code == BRACE_LEFT && depth++ == 0) {
-      lastIndex = srcStart;
-    } else if (code == BRACE_RIGHT && --depth == 0) {
-      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+    if (load<u16>(srcStart) == BRACE_LEFT) {
+      const obj = new JSON.Obj();
+      srcStart = parseObjectBody(obj, srcStart + 2, srcEnd);
+      out.push(changetype<valueof<T>>(changetype<usize>(obj)));
+    } else {
+      srcStart += 2;
     }
-    srcStart += 2;
   }
   return out;
 }

package/assembly/deserialize/naive/array/struct.ts

@@ -34,14 +34,32 @@ export function deserializeStructArray<T extends unknown[]>(
         (srcEnd - srcStart).toString(),
     );
 
+  // Reuse existing element slots when `dst` already holds elements (no per-call
+  // allocation on a reused array); fall back to push for fresh/extra slots and
+  // trim any leftovers from a previous, longer parse.
+  let index = 0;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
     if (code == BRACE_LEFT && depth++ == 0) {
       lastIndex = srcStart;
     } else if (code == BRACE_RIGHT && --depth == 0) {
-      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+      const valueEnd = (srcStart += 2);
+      if (<usize>index < <usize>out.length) {
+        const slot = changetype<usize>(unchecked(out[index]));
+        if (slot != 0) {
+          JSON.__deserialize<valueof<T>>(lastIndex, valueEnd, slot);
+        } else {
+          unchecked(
+            (out[index] = JSON.__deserialize<valueof<T>>(lastIndex, valueEnd)),
+          );
+        }
+      } else {
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, valueEnd));
+      }
+      index++;
     }
     srcStart += 2;
   }
+  if (<usize>index < <usize>out.length) out.length = index;
   return out;
 }

package/assembly/deserialize/naive/bool.ts

@@ -1,8 +1,4 @@
-// @ts-ignore: inline
-@inline export function deserializeBoolean(
-  srcStart: usize,
-  srcEnd: usize,
-): boolean {
+export function deserializeBoolean(srcStart: usize, srcEnd: usize): boolean {
   const block = load<u64>(srcStart);
   if (block == 28429475166421108) return true;
   else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101)

package/assembly/deserialize/naive/date.ts

@@ -1,7 +1,6 @@
 import { ptrToStr } from "../../util/ptrToStr";
 
-// @ts-ignore: inline
-@inline export function deserializeDate(srcStart: usize, srcEnd: usize): Date {
+export function deserializeDate(srcStart: usize, srcEnd: usize): Date {
   // Use AssemblyScript's date parser
   const d = Date.fromString(ptrToStr(srcStart + 2, srcEnd - 2));
 

package/assembly/deserialize/naive/float.ts

@@ -7,8 +7,7 @@ import { isSpace } from "../../util";
 // 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 {
+function validateJSONNumber(srcStart: usize, srcEnd: usize): void {
   let ptr = srcStart;
   while (ptr < srcEnd && isSpace(load<u16>(ptr))) ptr += 2;
   let end = srcEnd;
@@ -62,11 +61,7 @@ import { isSpace } from "../../util";
   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 {
+export function deserializeFloat_NAIVE<T>(srcStart: usize, srcEnd: usize): T {
   validateJSONNumber(srcStart, srcEnd);
   // @ts-ignore
   const type: T = 0;
@@ -76,8 +71,7 @@ import { isSpace } from "../../util";
   return f32.parse(ptrToStr(srcStart, srcEnd));
 }
 
-// @ts-ignore: inline
-@inline function scanFloatEnd(srcStart: usize, srcEnd: usize): usize {
+function scanFloatEnd(srcStart: usize, srcEnd: usize): usize {
   let ptr = srcStart;
   if (ptr < srcEnd && load<u16>(ptr) == 45) ptr += 2; // optional minus
 
@@ -115,8 +109,7 @@ import { isSpace } from "../../util";
   return ptr;
 }
 
-// @ts-ignore: inline
-@inline export function deserializeFloatField_NAIVE<T extends number>(
+export function deserializeFloatField_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/naive/integer.ts

@@ -1,15 +1,13 @@
 import { atoi } from "../../util/atoi";
 
-// @ts-ignore: inline
-@inline export function deserializeInteger_NAIVE<T extends number>(
+export function deserializeInteger_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
   return atoi<T>(srcStart, srcEnd);
 }
 
-// @ts-ignore: inline
-@inline export function deserializeIntegerField_NAIVE<T extends number>(
+export function deserializeIntegerField_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,