json-as 1.3.6 → 1.3.7

package/assembly/deserialize/simple/object.ts

@@ -1,6 +1,18 @@
 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";
@@ -10,7 +22,11 @@ import { deserializeBoolean } from "./bool";
 import { deserializeFloat } from "./float";
 import { deserializeString } 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;
@@ -22,9 +38,18 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
   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 +62,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 +80,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(lastIndex, srcStart + 2),
+        );
         srcStart += 2;
         keyStart = 0;
         continue;
@@ -63,7 +96,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<f64>(lastIndex, srcStart),
+            );
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -82,11 +118,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 +145,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 +203,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/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));
 }

package/assembly/deserialize/simple/set.ts

@@ -1,5 +1,14 @@
 import { JSON } from "../..";
-import { BRACKET_LEFT, BRACKET_RIGHT, BRACE_LEFT, BRACE_RIGHT, CHAR_F, CHAR_T, COMMA, QUOTE } from "../../custom/chars";
+import {
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  CHAR_F,
+  CHAR_T,
+  COMMA,
+  QUOTE,
+} from "../../custom/chars";
 import { isSpace, atoi, scanStringEnd } from "../../util";
 
 // @ts-expect-error: Decorator valid here
@@ -41,16 +50,24 @@ import { isSpace, atoi, scanStringEnd } from "../../util";
   return 0;
 }
 
-function deserializeSetDirect<T extends Set<any>>(srcStart: usize, srcEnd: usize, out: nonnull<T>, allowWhitespace: bool = false): usize {
-  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of set");
+function deserializeSetDirect<T extends Set<any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: nonnull<T>,
+  allowWhitespace: bool = false,
+): usize {
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Expected '[' at start of set");
 
   srcStart += 2;
-  if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (allowWhitespace)
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   if (srcStart >= srcEnd) throw new Error("Unterminated set");
   if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
 
   while (srcStart < srcEnd) {
-    if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (allowWhitespace)
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     const code = load<u16>(srcStart);
 
     // @ts-ignore: type
@@ -80,7 +97,12 @@ function deserializeSetDirect<T extends Set<any>>(srcStart: usize, srcEnd: usize
       let ptr = srcStart + 2;
       while (ptr < srcEnd) {
         const next = load<u16>(ptr);
-        if (next == COMMA || next == BRACKET_RIGHT || (allowWhitespace && isSpace(next))) break;
+        if (
+          next == COMMA ||
+          next == BRACKET_RIGHT ||
+          (allowWhitespace && isSpace(next))
+        )
+          break;
         ptr += 2;
       }
       // @ts-ignore: type
@@ -92,7 +114,12 @@ function deserializeSetDirect<T extends Set<any>>(srcStart: usize, srcEnd: usize
       let ptr = srcStart + 2;
       while (ptr < srcEnd) {
         const next = load<u16>(ptr);
-        if (next == COMMA || next == BRACKET_RIGHT || (allowWhitespace && isSpace(next))) break;
+        if (
+          next == COMMA ||
+          next == BRACKET_RIGHT ||
+          (allowWhitespace && isSpace(next))
+        )
+          break;
         ptr += 2;
       }
       // @ts-ignore: type
@@ -109,12 +136,14 @@ function deserializeSetDirect<T extends Set<any>>(srcStart: usize, srcEnd: usize
       break;
     }
 
-    if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (allowWhitespace)
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
     const next = load<u16>(srcStart);
     if (next == COMMA) {
       srcStart += 2;
-      if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+      if (allowWhitespace)
+        while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
       continue;
     }
     if (next == BRACKET_RIGHT) return srcStart + 2;
@@ -124,27 +153,43 @@ function deserializeSetDirect<T extends Set<any>>(srcStart: usize, srcEnd: usize
   throw new Error("Failed to parse JSON!");
 }
 
-export function deserializeSet<T extends Set<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeSet<T extends Set<any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   out.clear();
 
   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 (srcStart >= srcEnd)
+    throw new Error("Input string had zero length or was all whitespace");
   const end = deserializeSetDirect<T>(srcStart, srcEnd, out, true);
   if (end != srcEnd) throw new Error("Expected ']' at end of set");
   return out;
 }
 
 // @ts-expect-error: Decorator valid here
-@inline export function deserializeSetInto<T extends Set<any>>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function deserializeSetInto<T extends Set<any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   changetype<nonnull<T>>(out).clear();
   return deserializeSetDirect<T>(srcStart, srcEnd, changetype<nonnull<T>>(out));
 }
 
 // @ts-expect-error: Decorator valid here
-@inline export function deserializeSetField<T extends Set<any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+@inline export function deserializeSetField<T extends Set<any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
   let out = load<T>(dstObj, dstOffset);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());

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

@@ -2,7 +2,11 @@ import { JSON } from "../../..";
 import { QUOTE } from "../../../custom/chars";
 import { isUnescapedQuote } from "../../../util";
 
-export function deserializeStaticArrayString(srcStart: usize, srcEnd: usize, dst: usize): StaticArray<string> {
+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;
@@ -22,7 +26,9 @@ export function deserializeStaticArrayString(srcStart: usize, srcEnd: usize, dst
 
   // Allocate StaticArray with correct size
   const outSize = (<usize>count) << alignof<string>();
-  const out = changetype<StaticArray<string>>(dst || __new(outSize, idof<StaticArray<string>>()));
+  const out = changetype<StaticArray<string>>(
+    dst || __new(outSize, idof<StaticArray<string>>()),
+  );
 
   // Second pass: populate values
   let index = 0;
@@ -35,7 +41,9 @@ export function deserializeStaticArrayString(srcStart: usize, srcEnd: usize, dst
         inString = true;
         lastPos = srcStart;
       } else if (isUnescapedQuote(srcStart)) {
-        unchecked((out[index++] = JSON.__deserialize<string>(lastPos, srcStart + 2)));
+        unchecked(
+          (out[index++] = JSON.__deserialize<string>(lastPos, srcStart + 2)),
+        );
         inString = false;
       }
     }

package/assembly/deserialize/simple/staticarray.ts

@@ -18,7 +18,10 @@ import { deserializeStaticArrayString } from "./staticarray/string";
 import { scanValueEnd } from "../swar/array/shared";
 
 
-@inline function materializeStaticArray<T extends StaticArray<any>>(src: valueof<T>[], dst: usize): T {
+@inline function materializeStaticArray<T extends StaticArray<any>>(
+  src: valueof<T>[],
+  dst: usize,
+): T {
   const byteLength = <usize>src.length * sizeof<valueof<T>>();
   let out = dst;
 
@@ -35,7 +38,11 @@ import { scanValueEnd } from "../swar/array/shared";
   return typed;
 }
 
-export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeStaticArray<T extends StaticArray<any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
   if (isString<valueof<T>>()) {
     return changetype<T>(deserializeStaticArrayString(srcStart, srcEnd, dst));
   } else if (isBoolean<valueof<T>>()) {
@@ -45,27 +52,61 @@ export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usi
   } else if (isFloat<valueof<T>>()) {
     return deserializeStaticArrayFloat<T>(srcStart, srcEnd, dst);
   } else if (isArray<valueof<T>>()) {
-    return materializeStaticArray<T>(deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+    return materializeStaticArray<T>(
+      deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0),
+      dst,
+    );
   } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
     const type = changetype<nonnull<valueof<T>>>(0);
     if (type instanceof StaticArray) {
-      return materializeStaticArray<T>(deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+      return materializeStaticArray<T>(
+        deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0),
+        dst,
+      );
     } else if (type instanceof JSON.Value) {
-      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeArbitraryArray(srcStart, srcEnd, 0)), dst);
+      return materializeStaticArray<T>(
+        changetype<valueof<T>[]>(
+          deserializeArbitraryArray(srcStart, srcEnd, 0),
+        ),
+        dst,
+      );
     } else if (type instanceof JSON.Box) {
-      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeBoxArray<valueof<T>[]>(srcStart, srcEnd, 0)), dst);
+      return materializeStaticArray<T>(
+        changetype<valueof<T>[]>(
+          deserializeBoxArray<valueof<T>[]>(srcStart, srcEnd, 0),
+        ),
+        dst,
+      );
     } else if (type instanceof JSON.Obj) {
-      return materializeStaticArray<T>(deserializeObjectArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+      return materializeStaticArray<T>(
+        deserializeObjectArray<valueof<T>[]>(srcStart, srcEnd, 0),
+        dst,
+      );
     } else if (type instanceof JSON.Raw) {
-      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeRawArray(srcStart, srcEnd, 0)), dst);
+      return materializeStaticArray<T>(
+        changetype<valueof<T>[]>(deserializeRawArray(srcStart, srcEnd, 0)),
+        dst,
+      );
     } else if (type instanceof Map) {
-      return materializeStaticArray<T>(deserializeMapArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+      return materializeStaticArray<T>(
+        deserializeMapArray<valueof<T>[]>(srcStart, srcEnd, 0),
+        dst,
+      );
       // @ts-ignore: supplied by transform
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
-      return materializeStaticArray<T>(deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+      return materializeStaticArray<T>(
+        deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0),
+        dst,
+      );
       // @ts-ignore: supplied by transform
-    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
-      return materializeStaticArray<T>(deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+    } else if (
+      isDefined(type.__DESERIALIZE_SLOW) ||
+      isDefined(type.__DESERIALIZE_FAST)
+    ) {
+      return materializeStaticArray<T>(
+        deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0),
+        dst,
+      );
     }
   }
 
@@ -73,12 +114,21 @@ export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usi
 }
 
 
-@inline export function deserializeStaticArrayField<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+@inline export function deserializeStaticArrayField<T extends StaticArray<any>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
   const valueEnd = scanValueEnd(srcStart, srcEnd);
   if (!valueEnd) throw new Error("Failed to parse JSON!");
 
   const fieldPtr = dstObj + dstOffset;
-  const out = deserializeStaticArray<T>(srcStart, valueEnd, load<usize>(fieldPtr));
+  const out = deserializeStaticArray<T>(
+    srcStart,
+    valueEnd,
+    load<usize>(fieldPtr),
+  );
   store<T>(fieldPtr, out);
   return valueEnd;
 }

package/assembly/deserialize/simple/string.ts

@@ -1,35 +1,12 @@
-import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
-import { __heap_base } from "memory";
 import { bs } from "../../../lib/as-bs";
-import { BACK_SLASH, QUOTE } from "../../custom/chars";
-import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
+import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
 
 // @ts-ignore: inline
-@inline function writeStringToField(dstFieldPtr: usize, srcStart: usize, byteLength: u32): void {
-  if (byteLength == 0) {
-    store<usize>(dstFieldPtr, changetype<usize>(""));
-    return;
-  }
-
-  const current = load<usize>(dstFieldPtr);
-  let stringPtr: usize;
-  if (current >= __heap_base) {
-    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
-      stringPtr = current;
-    } else {
-      stringPtr = __renew(current, byteLength);
-      store<usize>(dstFieldPtr, stringPtr);
-    }
-  } else {
-    stringPtr = __new(byteLength, idof<string>());
-    store<usize>(dstFieldPtr, stringPtr);
-  }
-  memory.copy(stringPtr, srcStart, byteLength);
-}
-
-// @ts-ignore: inline
-@inline export function deserializeString(srcStart: usize, srcEnd: usize): string {
+@inline export function deserializeString(
+  srcStart: usize,
+  srcEnd: usize,
+): string {
   // Strip quotes
   srcStart += 2;
   srcEnd -= 2;
@@ -66,67 +43,3 @@ import { hex4_to_u16_swar } from "../../util/swar";
   }
   return bs.sliceOut<string>(outStart);
 }
-
-// @ts-ignore: inline
-@inline export function deserializeStringField<T extends string | null>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
-  const dstFieldPtr = dstObj + dstOffset;
-  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
-
-  const payloadStart = srcStart + 2;
-  srcStart = payloadStart;
-
-  while (srcStart < srcEnd) {
-    const char = load<u16>(srcStart);
-    if (char == QUOTE) {
-      writeStringToField(dstFieldPtr, payloadStart, <u32>(srcStart - payloadStart));
-      return srcStart + 2;
-    }
-    if (char != BACK_SLASH) {
-      srcStart += 2;
-      continue;
-    }
-
-    bs.offset = bs.buffer;
-    bs.ensureSize(u32(srcEnd - payloadStart));
-    const prefixLen = <u32>(srcStart - payloadStart);
-    if (prefixLen != 0) {
-      memory.copy(bs.buffer, payloadStart, prefixLen);
-      bs.offset += prefixLen;
-    }
-
-    while (srcStart < srcEnd) {
-      const block = load<u16>(srcStart);
-      if (block == QUOTE) {
-        writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-        bs.offset = bs.buffer;
-        return srcStart + 2;
-      }
-
-      if (block != BACK_SLASH) {
-        store<u16>(bs.offset, block);
-        srcStart += 2;
-        bs.offset += 2;
-        continue;
-      }
-
-      srcStart += 2;
-      const code = load<u16>(srcStart);
-      if (code !== 0x75) {
-        const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + code);
-        store<u16>(bs.offset, escape);
-        srcStart += 2;
-      } else {
-        const escaped = hex4_to_u16_swar(load<u64>(srcStart, 2));
-        store<u16>(bs.offset, escaped);
-        srcStart += 10;
-      }
-      bs.offset += 2;
-    }
-
-    bs.offset = bs.buffer;
-    break;
-  }
-
-  abort("Unterminated string literal");
-  return srcStart;
-}

package/assembly/deserialize/simple/struct.ts

@@ -1,4 +1,8 @@
-export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeStruct<T>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
   const out = changetype<nonnull<T>>(dst || __new(offsetof<T>(), idof<T>()));
 
   // @ts-ignore: supplied by transform

package/assembly/deserialize/simple/typedarray.ts

@@ -25,7 +25,11 @@ import { atoi, isSpace } from "../../util";
   return count;
 }
 
-export function deserializeTypedArray<T extends ArrayLike<number>>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
+export function deserializeTypedArray<T extends ArrayLike<number>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): T {
   const count = countTypedArrayElements(srcStart, srcEnd);
   let out = changetype<T>(dst || changetype<usize>(instantiate<T>(count)));
 
@@ -44,7 +48,12 @@ export function deserializeTypedArray<T extends ArrayLike<number>>(srcStart: usi
         const code = load<u16>(srcStart);
         if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
           if (isFloat<valueof<T>>()) {
-            unchecked((out[index++] = deserializeFloat<valueof<T>>(lastIndex, srcStart)));
+            unchecked(
+              (out[index++] = deserializeFloat<valueof<T>>(
+                lastIndex,
+                srcStart,
+              )),
+            );
           } else {
             unchecked((out[index++] = atoi<valueof<T>>(lastIndex, srcStart)));
           }
@@ -60,7 +69,11 @@ export function deserializeTypedArray<T extends ArrayLike<number>>(srcStart: usi
   return out;
 }
 
-export function deserializeArrayBuffer(srcStart: usize, srcEnd: usize, dst: usize = 0): ArrayBuffer {
+export function deserializeArrayBuffer(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): ArrayBuffer {
   const count = countTypedArrayElements(srcStart, srcEnd);
   let out = dst ? changetype<ArrayBuffer>(dst) : new ArrayBuffer(count);
 

package/assembly/deserialize/simple/unsigned.ts

@@ -1,12 +1,20 @@
 import { atoi } from "../../util/atoi";
 
 // @ts-ignore: inline
-@inline export function deserializeUnsigned<T>(srcStart: usize, srcEnd: usize): T {
+@inline export function deserializeUnsigned<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
   return atoi<T>(srcStart, srcEnd);
 }
 
 // @ts-ignore: inline
-@inline export function deserializeUnsignedField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+@inline export function deserializeUnsignedField<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
   const fieldPtr = dstObj + dstOffset;
   let digit = <u32>load<u16>(srcStart) - 48;
   if (digit > 9) unreachable();
@@ -61,16 +69,3 @@ import { atoi } from "../../util/atoi";
     return srcStart;
   }
 }
-
-export function deserializeUnsignedScan<T extends number>(src: usize, dst: usize): usize {
-  let digit = <T>load<u16>(src) - 48;
-  if (digit > 9) abort("Found invalid digit");
-  let val = digit;
-  src += 2;
-  while ((digit = <u32>load<u16>(src) - 48) < 10) {
-    val = val * 10 + digit;
-    src += 2;
-  }
-  store<T>(dst, val);
-  return src;
-}

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

@@ -2,7 +2,11 @@ import { JSON } from "../../..";
 import { ensureArrayField } from "./shared";
 
 
-@inline export function deserializeArbitraryArrayField(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeArbitraryArrayField(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
   ensureArrayField<JSON.Value[]>(fieldPtr);
   throw new Error("Failed to parse JSON!");
 }