json-as 1.3.6 → 1.3.8

package/assembly/deserialize/{simple → naive}/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,21 @@ 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>,
+): 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;
+  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;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     const code = load<u16>(srcStart);
 
     // @ts-ignore: type
@@ -80,7 +94,7 @@ 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 || isSpace(next)) break;
         ptr += 2;
       }
       // @ts-ignore: type
@@ -92,7 +106,7 @@ 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 || isSpace(next)) break;
         ptr += 2;
       }
       // @ts-ignore: type
@@ -109,12 +123,12 @@ function deserializeSetDirect<T extends Set<any>>(srcStart: usize, srcEnd: usize
       break;
     }
 
-    if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    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;
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
       continue;
     }
     if (next == BRACKET_RIGHT) return srcStart + 2;
@@ -124,31 +138,47 @@ 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");
-  const end = deserializeSetDirect<T>(srcStart, srcEnd, out, true);
+  if (srcStart >= srcEnd)
+    throw new Error("Input string had zero length or was all whitespace");
+  const end = deserializeSetDirect<T>(srcStart, srcEnd, out);
   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 function deserializeSetBody<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 {
-  let out = load<T>(dstObj, dstOffset);
+@inline export function deserializeSetField<T extends Set<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 deserializeSetInto<T>(srcStart, srcEnd, out);
+  return deserializeSetBody<T>(srcStart, srcEnd, out);
 }

package/assembly/deserialize/{simple → naive}/staticarray/array.ts

@@ -19,7 +19,7 @@ export function deserializeStaticArrayArray<T extends StaticArray<any>>(
     ptr += 2;
   }
 
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

package/assembly/deserialize/{simple → naive}/staticarray/bool.ts

@@ -20,7 +20,7 @@ export function deserializeStaticArrayBoolean<T extends StaticArray<any>>(
   }
 
   // Allocate StaticArray with correct size
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

package/assembly/deserialize/{simple → naive}/staticarray/float.ts

@@ -23,7 +23,7 @@ export function deserializeStaticArrayFloat<T extends StaticArray<any>>(
     ptr += 2;
   }
 
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   let index = 0;

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

@@ -22,7 +22,7 @@ export function deserializeStaticArrayInteger<T extends StaticArray<any>>(
     ptr += 2;
   }
 
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

package/assembly/deserialize/{simple → naive}/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 → naive}/staticarray/struct.ts

@@ -12,7 +12,6 @@ export function deserializeStaticArrayStruct<T extends StaticArray<any>>(
   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)
@@ -44,7 +43,7 @@ export function deserializeStaticArrayStruct<T extends StaticArray<any>>(
   }
 
   // Allocate StaticArray with correct size
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

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

@@ -4,21 +4,24 @@ import { deserializeArbitraryArray } from "./array/arbitrary";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
 import { deserializeBoxArray } from "./array/box";
-import { deserializeFloatArray } from "./array/float";
-import { deserializeIntegerArray } from "./array/integer";
+import { deserializeFloatArray_NAIVE } from "./array/float";
+import { deserializeIntegerArray_NAIVE } from "./array/integer";
 import { deserializeMapArray } from "./array/map";
 import { deserializeObjectArray } from "./array/object";
 import { deserializeRawArray } from "./array/raw";
 import { deserializeStructArray } from "./array/struct";
-import { deserializeStringArray } from "./array/string";
+import { deserializeStringArray_NAIVE } from "./array/string";
 import { deserializeStaticArrayBoolean } from "./staticarray/bool";
 import { deserializeStaticArrayFloat } from "./staticarray/float";
 import { deserializeStaticArrayInteger } from "./staticarray/integer";
 import { deserializeStaticArrayString } from "./staticarray/string";
-import { scanValueEnd } from "../swar/array/shared";
+import { scanValueEnd } from "../../util/scanValueEnd";
 
 
-@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/naive/string.ts

@@ -0,0 +1,199 @@
+import { bs } from "../../../lib/as-bs";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { __heap_base } from "memory";
+import { BACK_SLASH, QUOTE } from "../../custom/chars";
+import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+
+// @ts-ignore: inline
+@inline function hexDigit(c: u16): u32 {
+  if (c <= 0x39) return c - 0x30; // '0'-'9'
+  if (c <= 0x46) return c - 0x37; // 'A'-'F'
+  return c - 0x57; // 'a'-'f'
+}
+
+// @ts-ignore: inline
+@inline function hex4ToU16(srcStart: usize): u16 {
+  return <u16>(
+    ((hexDigit(load<u16>(srcStart)) << 12) |
+      (hexDigit(load<u16>(srcStart, 2)) << 8) |
+      (hexDigit(load<u16>(srcStart, 4)) << 4) |
+      hexDigit(load<u16>(srcStart, 6)))
+  );
+}
+
+// @ts-ignore: inline
+@inline function isHexDigit(c: u16): bool {
+  return (
+    (c >= 0x30 && c <= 0x39) ||
+    (c >= 0x41 && c <= 0x46) ||
+    (c >= 0x61 && c <= 0x66)
+  );
+}
+
+// Strict RFC 8259 check for the char following a backslash, at [escPtr, srcEnd).
+// Legal escapes: " \ / b f n r t and \uXXXX (4 hex digits). Throws otherwise:
+// unknown escape letter, a trailing backslash, or a short / non-hex \u.
+// @ts-ignore: inline
+@inline function validateEscape(escPtr: usize, srcEnd: usize): void {
+  if (escPtr >= srcEnd)
+    throw new Error("Invalid JSON string: incomplete escape");
+  const code = load<u16>(escPtr);
+  if (code == 0x75) {
+    // \uXXXX
+    if (escPtr + 10 > srcEnd)
+      throw new Error("Invalid JSON string: incomplete \\u escape");
+    if (
+      !isHexDigit(load<u16>(escPtr, 2)) ||
+      !isHexDigit(load<u16>(escPtr, 4)) ||
+      !isHexDigit(load<u16>(escPtr, 6)) ||
+      !isHexDigit(load<u16>(escPtr, 8))
+    )
+      throw new Error("Invalid JSON string: \\u escape needs 4 hex digits");
+    return;
+  }
+  // short escapes: " \ / b f n r t
+  if (
+    code != 0x22 &&
+    code != 0x5c &&
+    code != 0x2f &&
+    code != 0x62 &&
+    code != 0x66 &&
+    code != 0x6e &&
+    code != 0x72 &&
+    code != 0x74
+  )
+    throw new Error("Invalid JSON string: illegal escape");
+}
+
+// @ts-ignore: inline
+@inline export function deserializeString_NAIVE(
+  srcStart: usize,
+  srcEnd: usize,
+): string {
+  // RFC 8259: a string is quote-framed. All callers pass quote-inclusive
+  // bounds, so the first and last chars must be `"` (rejects `"` alone and
+  // trailing garbage like `""x`).
+  if (
+    srcEnd - srcStart < 4 ||
+    load<u16>(srcStart) != QUOTE ||
+    load<u16>(srcEnd - 2) != QUOTE
+  )
+    throw new Error("Invalid JSON string: missing surrounding quotes");
+  // Strip quotes
+  srcStart += 2;
+  srcEnd -= 2;
+  const outStart = bs.offset - bs.buffer;
+  bs.ensureSize(u32(srcEnd - srcStart));
+
+  while (srcStart < srcEnd) {
+    const block = load<u16>(srcStart);
+    store<u16>(bs.offset, block);
+    srcStart += 2;
+
+    // Early exit
+    if (block !== 0x5c) {
+      // RFC 8259: literal control chars (U+0000..U+001F) must be escaped.
+      if (block < 0x20)
+        throw new Error("Invalid JSON string: unescaped control character");
+      bs.offset += 2;
+      continue;
+    }
+
+    validateEscape(srcStart, srcEnd);
+    const code = load<u16>(srcStart);
+    if (code !== 0x75) {
+      // Short escapes (\n \t \" \\)
+      const block = load<u16>(srcStart);
+      const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + block);
+      store<u16>(bs.offset, escape);
+      srcStart += 2;
+    } else {
+      // Unicode escape (\uXXXX)
+      const escaped = hex4ToU16(srcStart + 2);
+      store<u16>(bs.offset, escaped);
+      srcStart += 10;
+    }
+
+    bs.offset += 2;
+  }
+  return bs.sliceOut<string>(outStart);
+}
+
+// Writes into the destination field, reusing or resizing the backing string.
+// Mirrors `writeStringToField` in ../swar/string.ts.
+// @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 deserializeStringField_NAIVE<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;
+
+  bs.offset = bs.buffer;
+  bs.ensureSize(<u32>(srcEnd - payloadStart));
+
+  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);
+      bs.offset += 2;
+      srcStart += 2;
+      continue;
+    }
+
+    const code = load<u16>(srcStart, 2);
+    if (code !== 0x75) {
+      // Short escapes (\n \t \" \\)
+      store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+      srcStart += 4;
+    } else {
+      // Unicode escape (\uXXXX)
+      store<u16>(bs.offset, hex4ToU16(srcStart + 4));
+      srcStart += 12;
+    }
+    bs.offset += 2;
+  }
+
+  abort("Expected closing quote");
+  return 0;
+}

package/assembly/deserialize/{simple → naive}/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 → naive}/typedarray.ts

@@ -1,5 +1,5 @@
 import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
-import { deserializeFloat } from "./float";
+import { deserializeFloat_NAIVE } from "./float";
 import { atoi, isSpace } from "../../util";
 
 
@@ -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_NAIVE<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_NAIVE<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_NAIVE(
+  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 → naive}/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_NAIVE<T extends number>(
+  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_NAIVE<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;
-}