json-as 1.2.3 → 1.2.5

package/assembly/deserialize/simd/string.ts

@@ -3,7 +3,7 @@ import { BACK_SLASH } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
 
-// @ts-ignore: decorator allowed
+// @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_5C = i16x8.splat(0x5C); // \
 
 // Overflow Pattern for Unicode Escapes (READ)
@@ -71,15 +71,17 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
     const block = load<v128>(srcStart);
     store<v128>(bs.offset, block);
 
-    const eq5C = i16x8.eq(load<v128>(srcStart), SPLAT_5C);
-    let mask = i16x8.bitmask(eq5C);
+    const eq5C = i16x8.eq(block, SPLAT_5C);
+
     // Early exit
-    if (mask === 0) {
+    if (!v128.any_true(eq5C)) {
       srcStart += 16;
       bs.offset += 16;
       continue;
     }
 
+    let mask = i16x8.bitmask(eq5C);
+
     let srcChg: usize = 0;
     let lastLane: usize = 0;
     do {
@@ -157,40 +159,3 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 
   return bs.out<string>();
 }
-
-/**
- * Computes a per-lane mask identifying UTF-16 code units whose **low byte**
- * is the ASCII backslash (`'\\'`, 0x5C).
- *
- * The mask is produced in two stages:
- * 1. Detects bytes equal to 0x5C using a SWAR equality test.
- * 2. Clears matches where 0x5C appears in the **high byte** of a UTF-16 code unit,
- *    ensuring only valid low-byte backslashes are reported.
- *
- * Each matching lane sets itself to 0x80.
- */
-// @ts-ignore: decorator
-@inline function backslash_mask(block: u64): u64 {
-  const b = block ^ 0x005C_005C_005C_005C;
-  const backslash_mask = (b - 0x0001_0001_0001_0001) & ~b & 0x0080_0080_0080_0080;
-  const high_byte_mask =
-    ~(((block - 0x0100_0100_0100_0100) & ~block & 0x8000_8000_8000_8000)
-      ^ 0x8000_8000_8000_8000) >> 8;
-  return backslash_mask & high_byte_mask;
-}
-
-/**
- * Computes a per-lane mask identifying UTF-16 code units whose **low byte**
- * is the ASCII backslash (`'\\'`, 0x5C).
- *
- * Each matching lane sets itself to 0x80.
- * 
- * WARNING: The low byte of a code unit *may* be a backslash, thus triggering false positives!
- * This is useful for a hot path where it is possible to detect the false positive scalarly.
- */
-// @ts-ignore: decorator
-@inline function backslash_mask_unsafe(block: u64): u64 {
-  const b = block ^ 0x005C_005C_005C_005C;
-  const backslash_mask = (b - 0x0001_0001_0001_0001) & ~b & 0x0080_0080_0080_0080;
-  return backslash_mask;
-}

package/assembly/deserialize/simple/set.ts

@@ -0,0 +1,169 @@
+import { JSON } from "../..";
+import { BACK_SLASH, BRACKET_LEFT, BRACKET_RIGHT, BRACE_LEFT, BRACE_RIGHT, CHAR_F, CHAR_N, CHAR_T, COMMA, QUOTE } from "../../custom/chars";
+import { isSpace, atoi } from "../../util";
+
+export function deserializeSet<T extends Set<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcStart >= srcEnd) throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of set");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT) throw new Error("Expected ']' at end of set");
+
+  srcStart += 2;
+
+  while (srcStart < srcEnd - 2) {
+    let code = load<u16>(srcStart);
+    while (isSpace(code)) code = load<u16>((srcStart += 2));
+
+    // @ts-ignore: type
+    if (isString<indexof<T>>()) {
+      if (code == QUOTE) {
+        const lastIndex = srcStart;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const c = load<u16>(srcStart);
+          if (c == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH) {
+            // @ts-ignore: type
+            out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart + 2));
+            srcStart += 2;
+            break;
+          }
+          srcStart += 2;
+        }
+      }
+    // @ts-ignore: type
+    } else if (isBoolean<indexof<T>>()) {
+      if (code == CHAR_T) {
+        // @ts-ignore: type
+        out.add(<indexof<T>>true);
+        srcStart += 8;
+      } else if (code == CHAR_F) {
+        // @ts-ignore: type
+        out.add(<indexof<T>>false);
+        srcStart += 10;
+      }
+    // @ts-ignore: type
+    } else if (isInteger<indexof<T>>()) {
+      if (code - 48 <= 9 || code == 45) {
+        const lastIndex = srcStart;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const c = load<u16>(srcStart);
+          if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
+            // @ts-ignore: type
+            out.add(atoi<indexof<T>>(lastIndex, srcStart));
+            break;
+          }
+          srcStart += 2;
+        }
+      }
+    // @ts-ignore: type
+    } else if (isFloat<indexof<T>>()) {
+      if (code - 48 <= 9 || code == 45) {
+        const lastIndex = srcStart;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const c = load<u16>(srcStart);
+          if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
+            // @ts-ignore: type
+            out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
+            break;
+          }
+          srcStart += 2;
+        }
+      }
+    // @ts-ignore: type
+    } else if (isManaged<indexof<T>>() || isReference<indexof<T>>()) {
+      // @ts-ignore: type
+      const type = changetype<nonnull<indexof<T>>>(0);
+      if (code == BRACE_LEFT) {
+        // Object
+        const lastIndex = srcStart;
+        let depth: u32 = 1;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const c = load<u16>(srcStart);
+          if (c == QUOTE) {
+            srcStart += 2;
+            while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
+          } else if (c == BRACE_RIGHT) {
+            if (--depth == 0) {
+              srcStart += 2;
+              // @ts-ignore: type
+              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
+              break;
+            }
+          } else if (c == BRACE_LEFT) {
+            depth++;
+          }
+          srcStart += 2;
+        }
+      } else if (code == BRACKET_LEFT) {
+        // Nested array/set
+        const lastIndex = srcStart;
+        let depth: u32 = 1;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const c = load<u16>(srcStart);
+          if (c == BRACKET_RIGHT) {
+            if (--depth == 0) {
+              srcStart += 2;
+              // @ts-ignore: type
+              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
+              break;
+            }
+          } else if (c == BRACKET_LEFT) {
+            depth++;
+          }
+          srcStart += 2;
+        }
+      } else if (type instanceof JSON.Raw) {
+        // Handle JSON.Raw
+        if (code == QUOTE) {
+          const lastIndex = srcStart;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const c = load<u16>(srcStart);
+            if (c == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH) {
+              // @ts-ignore: type
+              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart + 2));
+              srcStart += 2;
+              break;
+            }
+            srcStart += 2;
+          }
+        } else if (code - 48 <= 9 || code == 45) {
+          const lastIndex = srcStart;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const c = load<u16>(srcStart);
+            if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
+              // @ts-ignore: type
+              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
+              break;
+            }
+            srcStart += 2;
+          }
+        } else if (code == CHAR_T) {
+          // @ts-ignore: type
+          out.add(JSON.__deserialize<indexof<T>>(srcStart, srcStart + 8));
+          srcStart += 8;
+        } else if (code == CHAR_F) {
+          // @ts-ignore: type
+          out.add(JSON.__deserialize<indexof<T>>(srcStart, srcStart + 10));
+          srcStart += 10;
+        } else if (code == CHAR_N) {
+          // @ts-ignore: type
+          out.add(JSON.__deserialize<indexof<T>>(srcStart, srcStart + 8));
+          srcStart += 8;
+        }
+      }
+    }
+    srcStart += 2;
+  }
+
+  return out;
+}

package/assembly/deserialize/simple/staticarray/array.ts

@@ -0,0 +1,37 @@
+import { BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../../";
+
+export function deserializeStaticArrayArray<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  let count: i32 = 0;
+  let depth: u32 = 0;
+  let ptr = srcStart + 2;
+  while (ptr < srcEnd - 2) {
+    const code = load<u16>(ptr);
+    if (code == BRACKET_LEFT && depth++ == 0) {
+      // start of nested array
+    } else if (code == BRACKET_RIGHT && --depth == 0) {
+      count++;
+    }
+    ptr += 2;
+  }
+
+  const outSize = <usize>count << alignof<valueof<T>>();
+  const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
+
+  // Second pass: populate values
+  let index = 0;
+  let lastIndex: usize = 0;
+  depth = 0;
+  srcStart += 2;
+  while (srcStart < srcEnd - 2) {
+    const code = load<u16>(srcStart);
+    if (code == BRACKET_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACKET_RIGHT && --depth == 0) {
+      unchecked((out[index++] = JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2)));
+    }
+    srcStart += 2;
+  }
+
+  return out;
+}

package/assembly/deserialize/simple/staticarray/bool.ts

@@ -0,0 +1,39 @@
+export function deserializeStaticArrayBoolean<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  // First pass: count elements using same logic as Array deserializer
+  let count: i32 = 0;
+  let ptr = srcStart + 2; // skip [
+  while (ptr < srcEnd) {
+    const block = load<u64>(ptr);
+    if (block == 28429475166421108) {
+      count++;
+      ptr += 10;
+    } else if (block == 32370086184550502 && load<u16>(ptr, 8) == 101) {
+      count++;
+      ptr += 12;
+    } else {
+      ptr += 2;
+    }
+  }
+
+  // Allocate StaticArray with correct size
+  const outSize = <usize>count << alignof<valueof<T>>();
+  const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
+
+  // Second pass: populate values
+  let index = 0;
+  srcStart += 2; // skip [
+  while (srcStart < srcEnd) {
+    const block = load<u64>(srcStart);
+    if (block == 28429475166421108) {
+      unchecked((out[index++] = <valueof<T>>true));
+      srcStart += 10;
+    } else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) {
+      unchecked((out[index++] = <valueof<T>>false));
+      srcStart += 12;
+    } else {
+      srcStart += 2;
+    }
+  }
+
+  return out;
+}

package/assembly/deserialize/simple/staticarray/float.ts

@@ -0,0 +1,44 @@
+import { isSpace } from "../../../util";
+import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+
+export function deserializeStaticArrayFloat<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  let count: i32 = 0;
+  let ptr = srcStart;
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code - 48 <= 9 || code == 45) {
+      count++;
+      ptr += 2;
+      while (ptr < srcEnd) {
+        const code = load<u16>(ptr);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) break;
+        ptr += 2;
+      }
+    }
+    ptr += 2;
+  }
+
+  const outSize = <usize>count << alignof<valueof<T>>();
+  const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
+
+  let index = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      const lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          unchecked((out[index++] = JSON.__deserialize<valueof<T>>(lastIndex, srcStart)));
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+    srcStart += 2;
+  }
+
+  return out;
+}

package/assembly/deserialize/simple/staticarray/integer.ts

@@ -0,0 +1,44 @@
+import { atoi, isSpace } from "../../../util";
+import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
+
+export function deserializeStaticArrayInteger<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  let count: i32 = 0;
+  let ptr = srcStart;
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code - 48 <= 9 || code == 45) {
+      count++;
+      ptr += 2;
+      while (ptr < srcEnd) {
+        const code = load<u16>(ptr);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) break;
+        ptr += 2;
+      }
+    }
+    ptr += 2;
+  }
+
+  const outSize = <usize>count << alignof<valueof<T>>();
+  const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
+
+  // Second pass: populate values
+  let index = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      const lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          unchecked((out[index++] = atoi<valueof<T>>(lastIndex, srcStart)));
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+    srcStart += 2;
+  }
+
+  return out;
+}

package/assembly/deserialize/simple/staticarray/string.ts

@@ -0,0 +1,45 @@
+import { JSON } from "../../..";
+import { BACK_SLASH, QUOTE } from "../../../custom/chars";
+
+export function deserializeStaticArrayString(srcStart: usize, srcEnd: usize, dst: usize): StaticArray<string> {
+  // First pass: count elements using same logic as Array deserializer
+  let count: i32 = 0;
+  let ptr = srcStart;
+  let inString = false;
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code == QUOTE) {
+      if (!inString) {
+        inString = true;
+      } else if (load<u16>(ptr - 2) != BACK_SLASH) {
+        count++;
+        inString = false;
+      }
+    }
+    ptr += 2;
+  }
+
+  // Allocate StaticArray with correct size
+  const outSize = <usize>count << alignof<string>();
+  const out = changetype<StaticArray<string>>(dst || __new(outSize, idof<StaticArray<string>>()));
+
+  // Second pass: populate values
+  let index = 0;
+  let lastPos: usize = 0;
+  inString = false;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == QUOTE) {
+      if (!inString) {
+        inString = true;
+        lastPos = srcStart;
+      } else if (load<u16>(srcStart - 2) != BACK_SLASH) {
+        unchecked((out[index++] = JSON.__deserialize<string>(lastPos, srcStart + 2)));
+        inString = false;
+      }
+    }
+    srcStart += 2;
+  }
+
+  return out;
+}

package/assembly/deserialize/simple/staticarray/struct.ts

@@ -0,0 +1,47 @@
+import { BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+import { isSpace } from "util/string";
+
+export function deserializeStaticArrayStruct<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  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");
+
+  if (load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of object at position " + (srcEnd - srcStart).toString());
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT) throw new Error("Expected ']' at end of object at position " + (srcEnd - srcStart).toString());
+
+  // First pass: count elements using same logic as Array deserializer
+  let count: i32 = 0;
+  let depth: u32 = 0;
+  let ptr = srcStart;
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      // start of object
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      count++;
+    }
+    ptr += 2;
+  }
+
+  // Allocate StaticArray with correct size
+  const outSize = <usize>count << alignof<valueof<T>>();
+  const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
+
+  // Second pass: populate values
+  let index = 0;
+  let lastIndex: usize = 0;
+  depth = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      unchecked((out[index++] = JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2))));
+    }
+    srcStart += 2;
+  }
+
+  return out;
+}

package/assembly/deserialize/simple/staticarray.ts

@@ -0,0 +1,28 @@
+import { deserializeStaticArrayInteger } from "./staticarray/integer";
+import { deserializeStaticArrayFloat } from "./staticarray/float";
+import { deserializeStaticArrayBoolean } from "./staticarray/bool";
+import { deserializeStaticArrayString } from "./staticarray/string";
+import { deserializeStaticArrayArray } from "./staticarray/array";
+import { deserializeStaticArrayStruct } from "./staticarray/struct";
+
+export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  if (isString<valueof<T>>()) {
+    return <T>deserializeStaticArrayString(srcStart, srcEnd, dst);
+  } else if (isBoolean<valueof<T>>()) {
+    return deserializeStaticArrayBoolean<T>(srcStart, srcEnd, dst);
+  } else if (isInteger<valueof<T>>()) {
+    return deserializeStaticArrayInteger<T>(srcStart, srcEnd, dst);
+  } else if (isFloat<valueof<T>>()) {
+    return deserializeStaticArrayFloat<T>(srcStart, srcEnd, dst);
+  } else if (isArrayLike<valueof<T>>()) {
+    return deserializeStaticArrayArray<T>(srcStart, srcEnd, dst);
+  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+    const type = changetype<nonnull<valueof<T>>>(0);
+    if (isDefined(type.__DESERIALIZE)) {
+      return deserializeStaticArrayStruct<T>(srcStart, srcEnd, dst);
+    }
+    throw new Error("Could not parse static array of type " + nameof<T>() + "!");
+  } else {
+    throw new Error("Could not parse static array of type " + nameof<T>() + "!");
+  }
+}

package/assembly/deserialize/swar/string.ts

@@ -30,7 +30,7 @@ import { hex4_to_u16_swar } from "../../util/swar";
 // -\n-       2 -*-_       - 2
 // --\n       4 --*_       - 2
 // ---\n      6 ---*       - 0
-// Formula: overflow = 
+// Formula: overflow =
 
 /**
  * Deserializes strings back into into their original form using SIMD operations
@@ -48,7 +48,8 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
   while (srcStart < srcEnd8) {
     const block = load<u64>(srcStart);
     store<u64>(bs.offset, block);
-    let mask = backslash_mask_unsafe(block);
+
+    let mask = inline.always(backslash_mask_unsafe(block));
 
     // Early exit
     if (mask === 0) {
@@ -138,7 +139,7 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
  *
  * Each matching lane sets itself to 0x80.
  */
-// @ts-ignore: decorator
+// @ts-expect-error: @inline is a valid decorator
 @inline function backslash_mask(block: u64): u64 {
   const b = block ^ 0x005C_005C_005C_005C;
   const backslash_mask = (b - 0x0001_0001_0001_0001) & ~b & 0x0080_0080_0080_0080;
@@ -153,11 +154,11 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
  * is the ASCII backslash (`'\\'`, 0x5C).
  *
  * Each matching lane sets itself to 0x80.
- * 
+ *
  * WARNING: The low byte of a code unit *may* be a backslash, thus triggering false positives!
  * This is useful for a hot path where it is possible to detect the false positive scalarly.
  */
-// @ts-ignore: decorator
+// @ts-expect-error: @inline is a valid decorator
 @inline function backslash_mask_unsafe(block: u64): u64 {
   const b = block ^ 0x005C_005C_005C_005C;
   const backslash_mask = (b - 0x0001_0001_0001_0001) & ~b & 0x0080_0080_0080_0080;