json-as 0.9.29 → 1.0.0-alpha.2

package/assembly/index.ts

@@ -1,23 +1,30 @@
 /// <reference path="./index.d.ts" />
-import { serializeString } from "./serialize/string";
-import { serializeBool } from "./serialize/bool";
-import { serializeInteger } from "./serialize/integer";
-import { serializeFloat } from "./serialize/float";
-import { serializeObject } from "./serialize/object";
-import { serializeDate } from "./serialize/date";
-import { serializeArray } from "./serialize/array";
-import { serializeMap } from "./serialize/map";
-import { deserializeBoolean, deserializeBoolean_Safe } from "./deserialize/bool";
-import { deserializeArray, deserializeArray_Safe } from "./deserialize/array";
-import { deserializeFloat } from "./deserialize/float";
-import { deserializeObject, deserializeObject_Safe } from "./deserialize/object";
-import { deserializeMap, deserializeMap_Safe } from "./deserialize/map";
-import { deserializeDate } from "./deserialize/date";
-import { NULL_WORD } from "./custom/chars";
-import { deserializeInteger, deserializeInteger_Safe } from "./deserialize/integer";
-import { deserializeString, deserializeString_Safe } from "./deserialize/string";
+import { bs } from "../modules/as-bs";
+
+import { serializeString } from "./serialize/simple/string";
+import { serializeArray } from "./serialize/simple/array";
+import { serializeMap } from "./serialize/simple/map";
+import { deserializeBoolean } from "./deserialize/simple/bool";
+import { deserializeArray } from "./deserialize/simple/array";
+import { deserializeFloat } from "./deserialize/simple/float";
+import { deserializeObject } from "./deserialize/simple/object";
+import { deserializeMap } from "./deserialize/simple/map";
+import { deserializeDate } from "./deserialize/simple/date";
+import { deserializeInteger } from "./deserialize/simple/integer";
+import { deserializeString } from "./deserialize/simple/string";
+import { serializeArbitrary } from "./serialize/simple/arbitrary";
+
 import { Sink } from "./custom/sink";
-import { getArrayDepth } from "./custom/util";
+import { NULL_WORD, QUOTE } from "./custom/chars";
+import { dtoa_buffered, itoa_buffered } from "util/number";
+import { serializeBool } from "./serialize/simple/bool";
+import { serializeInteger } from "./serialize/simple/integer";
+import { serializeFloat } from "./serialize/simple/float";
+import { serializeObject } from "./serialize/simple/object";
+import { ptrToStr } from "./util/ptrToStr";
+import { bytes } from "./util";
+
+export type Raw = string;
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -29,6 +36,158 @@ import { getArrayDepth } from "./custom/util";
  * JSON Encoder/Decoder for AssemblyScript
  */
 export namespace JSON {
+  /**
+   * Serializes valid JSON data
+   * ```js
+   * JSON.stringify<T>(data)
+   * ```
+   * @param data T
+   * @returns string
+   */
+  export function stringify<T>(data: T, out: string | null = null): string {
+    if (isBoolean<T>()) {
+      if (out) {
+        if (<bool>data == true) {
+          out = changetype<string>(__renew(changetype<usize>(out), 8));
+          store<u64>(changetype<usize>(out), 28429475166421108);
+        } else {
+          out = changetype<string>(__renew(changetype<usize>(out), 10));
+          store<u64>(changetype<usize>(out), 32370086184550502);
+          store<u16>(changetype<usize>(out), 101, 8);
+        }
+        return out;
+      }
+      return data ? "true" : "false";
+    } else if (isInteger<T>() && nameof<T>() == "usize" && data == 0) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), 8));
+        store<u64>(changetype<usize>(out), 30399761348886638);
+        return out;
+      }
+      return NULL_WORD;
+    } else if (isInteger<T>(data)) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), sizeof<T>() << 3));
+
+        // @ts-ignore
+        const bytes = itoa_buffered(changetype<usize>(out), data) << 1;
+        return (out = changetype<string>(__renew(changetype<usize>(out), bytes)));
+      }
+      return data.toString();
+    } else if (isFloat<T>(data)) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), 64));
+
+        // @ts-ignore
+        const bytes = dtoa_buffered(changetype<usize>(out), data) << 1;
+        return (out = changetype<string>(__renew(changetype<usize>(out), bytes)));
+      }
+      return data.toString();
+      // @ts-ignore: Function is generated by transform
+    } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), 8));
+        store<u64>(changetype<usize>(out), 30399761348886638);
+        return out;
+      }
+      return NULL_WORD;
+      // @ts-ignore
+    } else if (isString<nonnull<T>>()) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), bytes(data) + 4));
+        // const oldSize = bs.byteLength;
+        const oldBuf = bs.buffer;
+        const newSize = bytes(data) + 4;
+        const newBuf = __new(newSize, idof<string>());
+        bs.setBuffer(newBuf);
+        serializeString(changetype<string>(data));
+        bs.setBuffer(oldBuf);
+        return changetype<string>(newBuf);
+      }
+      serializeString(changetype<string>(data));
+      return bs.out<string>();
+      // @ts-ignore: Supplied by transform
+    } else if (isDefined(data.__SERIALIZE) && isDefined(data.__ALLOCATE)) {
+      // @ts-ignore
+      data.__ALLOCATE();
+      // @ts-ignore
+      data.__SERIALIZE(changetype<usize>(data));
+      return bs.out<string>();
+      // @ts-ignore: Supplied by transform
+    } else if (data instanceof Date) {
+      out = out ? changetype<string>(__renew(changetype<usize>(out), 52)) : changetype<string>(__new(52, idof<string>()));
+
+      store<u16>(changetype<usize>(out), QUOTE);
+      memory.copy(changetype<usize>(out) + 2, changetype<usize>(data.toISOString()), 48);
+      store<u16>(changetype<usize>(out), 50);
+      return out;
+    } else if (data instanceof Array) {
+      // @ts-ignore
+      serializeArray(changetype<nonnull<T>>(data));
+      return bs.out<string>();
+    } else if (data instanceof Map) {
+      // @ts-ignore
+      serializeMap(changetype<nonnull<T>>(data));
+      return bs.out<string>();
+    } else if (data instanceof JSON.Value) {
+      serializeArbitrary(data);
+      return bs.out<string>();
+    } else if (data instanceof JSON.Box) {
+      return JSON.stringify(data.value);
+    } else {
+      ERROR(`Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
+    }
+  }
+
+  /**
+   * Parses valid JSON strings into their original format
+   * ```js
+   * JSON.parse<T>(data)
+   * ```
+   * @param data string
+   * @returns T
+   */
+  export function parse<T>(data: string): T {
+    const dataSize = bytes(data);
+    const dataPtr = changetype<usize>(data);
+    if (isBoolean<T>()) {
+      return deserializeBoolean(dataPtr, dataPtr + dataSize) as T;
+    } else if (isInteger<T>()) {
+      return deserializeInteger<T>(dataPtr, dataPtr + dataSize);
+    } else if (isFloat<T>()) {
+      return deserializeFloat<T>(dataPtr, dataPtr + dataSize);
+    } else if (isNullable<T>() && data.length == 4 && data == "null") {
+      // @ts-ignore
+      return null;
+    } else if (isString<T>()) {
+      // @ts-ignore
+      return deserializeString(dataPtr, dataPtr + dataSize);
+    } else if (isArray<T>()) {
+      // @ts-ignore
+      return deserializeArray<nonnull<T>>(dataPtr, dataPtr + dataSize, changetype<usize>(instantiate<T>()));
+    }
+    let type: nonnull<T> = changetype<nonnull<T>>(0);
+    // @ts-ignore: Defined by transform
+    if (isDefined(type.__DESERIALIZE) && isDefined(type.__INITIALIZE)) {
+      const out = __new(offsetof<nonnull<T>>(), idof<nonnull<T>>());
+      // @ts-ignore
+      changetype<nonnull<T>>(out).__INITIALIZE();
+      // @ts-ignore
+      return deserializeObject<nonnull<T>>(dataPtr, dataPtr + dataSize, out);
+    } else if (type instanceof Map) {
+      // @ts-ignore
+      return deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize);
+    } else if (type instanceof Date) {
+      // @ts-ignore
+      return deserializeDate(dataPtr, dataPtr + dataSize);
+    } else if (type instanceof JSON.Box) {
+      // @ts-ignore
+      return new JSON.Box(JSON.parse<indexof<T>>(data));
+    } else {
+      ERROR(`Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
+    }
+  }
+
   /**
    * Enum representing the different types supported by JSON.
    */
@@ -42,11 +201,15 @@ export namespace JSON {
     F64 = 6,
     Bool = 7,
     String = 8,
-    Obj = 8,
-    Array = 9,
+    Object = 9,
+    Array = 10,
+    Struct = 11,
   }
+
   export type Raw = string;
+
   export class Value {
+    static METHODS: Map<u32, u32> = new Map<u32, u32>();
     public type: i32;
 
     // @ts-ignore
@@ -103,11 +266,19 @@ export namespace JSON {
         if (idof<T>() !== idof<Map<string, JSON.Value>>()) {
           abort("Maps must be of type Map<string, JSON.Value>!");
         }
-        this.type = JSON.Types.Obj;
+        this.type = JSON.Types.Struct;
         store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (isArray<T>()) {
+        // @ts-ignore
+      } else if (isDefined(value.__SERIALIZE)) {
+        this.type = idof<T>() + JSON.Types.Struct;
+        // @ts-ignore
+        if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
+        // @ts-ignore
+        store<T>(changetype<usize>(this), value, STORAGE);
+        // @ts-ignore
+      } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
         // @ts-ignore: T satisfies constraints of any[]
-        this.type = JSON.Types.Array + getArrayDepth<T>(0);
+        this.type = JSON.Types.Array;
         store<T>(changetype<usize>(this), value, STORAGE);
       }
     }
@@ -122,7 +293,6 @@ export namespace JSON {
 
     /**
      * Converts the JSON.Value to a string representation.
-     * @param useString - If true, treats Buffer as a string.
      * @returns The string representation of the JSON.Value.
      */
     toString(): string {
@@ -139,7 +309,7 @@ export namespace JSON {
           return '"' + this.get<string>() + '"';
         case JSON.Types.Bool:
           return this.get<boolean>() ? "true" : "false";
-        default: {
+        case JSON.Types.Array: {
           const arr = this.get<JSON.Value[]>();
           if (!arr.length) return "[]";
           const out = Sink.fromStringLiteral("[");
@@ -156,158 +326,103 @@ export namespace JSON {
           out.write("]");
           return out.toString();
         }
+        default: {
+          const fn = JSON.Value.METHODS.get(this.type - JSON.Types.Struct);
+          const value = this.get<usize>();
+          return call_indirect<string>(fn, 0, value);
+        }
       }
     }
   }
+
+  /**
+   * Box for primitive types
+   */
   export class Box<T> {
     constructor(public value: T) {}
-
-
+    /**
+     * Creates a reference to a primitive type
+     * This means that it can create a nullable primitive
+     * ```js
+     * JSON.stringify<Box<i32> | null>(null);
+     * // null
+     * ```
+     * @param from T
+     * @returns Box<T>
+     */
     @inline static from<T>(value: T): Box<T> {
       return new Box(value);
     }
   }
 
-  /**
-   * Stringifies valid JSON data.
-   * ```js
-   * JSON.stringify<T>(data)
-   * ```
-   * @param data T
-   * @returns string
-   */
-  export function stringify<T>(data: T /*, options: SerializeOptions = DEFAULT_SERIALIZE_OPTIONS*/): string {
+  export function __serialize<T>(src: T): void {
     if (isBoolean<T>()) {
-      return serializeBool(data as bool);
-    } else if (isInteger<T>() && nameof<T>() == "usize" && data == 0) {
-      return NULL_WORD;
+      serializeBool(src as bool);
+    } else if (isInteger<T>() && nameof<T>() == "usize" && src == 0) {
+      bs.ensureSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
     } else if (isInteger<T>()) {
       // @ts-ignore
-      return serializeInteger<T>(data);
-    } else if (isFloat<T>(data)) {
+      serializeInteger<T>(src);
+    } else if (isFloat<T>(src)) {
       // @ts-ignore
-      return serializeFloat<T>(data);
+      serializeFloat<T>(src);
       // @ts-ignore: Function is generated by transform
-    } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
-      return NULL_WORD;
-      // @ts-ignore
+    } else if (isNullable<T>() && changetype<usize>(src) == <usize>0) {
+      bs.ensureSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
     } else if (isString<nonnull<T>>()) {
-      return serializeString(changetype<string>(data));
+      serializeString(src as string);
       // @ts-ignore: Supplied by transform
-    } else if (isDefined(data.__SERIALIZE)) {
-      /*if (options.pretty) {
-        // @ts-ignore
-        return serializeObject_Pretty(changetype<nonnull<T>>(data));
-      }*/
-      // @ts-ignore
-      return serializeObject(changetype<nonnull<T>>(data));
-    } else if (data instanceof Date) {
-      // @ts-ignore
-      return serializeDate(changetype<nonnull<T>>(data));
-    } else if (data instanceof Array) {
-      // @ts-ignore
-      return serializeArray(changetype<nonnull<T>>(data));
-    } else if (data instanceof Map) {
-      // @ts-ignore
-      return serializeMap(changetype<nonnull<T>>(data));
-    } else {
-      throw new Error(`Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
-    }
-  }
-  /**
-   * Parses valid JSON strings into their original format.
-   * ```js
-   * JSON.parse<T>(data)
-   * ```
-   * @param data string
-   * @returns T
-   */
-  export function parse<T>(data: string): T {
-    if (isBoolean<T>()) {
-      return deserializeBoolean(data) as T;
-    } else if (isInteger<T>()) {
-      return deserializeInteger<T>(data);
-    } else if (isFloat<T>()) {
-      return deserializeFloat<T>(data);
-    } else if (isNullable<T>() && data.length === 4 && data == "null") {
-      // @ts-ignore
-      return null;
-    } else if (isString<T>()) {
+    } else if (isDefined(src.__SERIALIZE)) {
       // @ts-ignore
-      return deserializeString(data);
-    } else if (isArray<T>()) {
-      // @ts-ignore
-      return deserializeArray<nonnull<T>>(data);
-    }
-    let type: nonnull<T> = changetype<nonnull<T>>(0);
-    // @ts-ignore: Defined by transform
-    if (isDefined(type.__DESERIALIZE)) {
+      serializeObject(changetype<nonnull<T>>(src));
+    } else if (src instanceof Date) {
       // @ts-ignore
-      return deserializeObject<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Map) {
+      serializeDate(changetype<nonnull<T>>(src));
+    } else if (src instanceof Array) {
       // @ts-ignore
-      return deserializeMap<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Date) {
+      serializeArray(changetype<nonnull<T>>(src));
+    } else if (src instanceof Map) {
       // @ts-ignore
-      return deserializeDate(data);
+      serializeMap(changetype<nonnull<T>>(src));
+    } else if (src instanceof JSON.Value) {
+      serializeArbitrary(src);
+    } else if (src instanceof JSON.Box) {
+      __serialize(src.value);
     } else {
-      throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
+      ERROR(`Could not serialize provided data. Make sure to add the correct decorators to classes.`);
     }
   }
-  /**
-   * Parses valid JSON strings into their original format (safely).
-   * ```js
-   * JSON.parseSafe<T>(data)
-   * ```
-   * @param data string
-   * @returns T
-   */
-
-  // @ts-ignore: Decorator
-  @inline export function parseSafe<T>(data: string): T {
+  export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
     if (isBoolean<T>()) {
-      return deserializeBoolean_Safe(data) as T;
+      // @ts-ignore: type
+      return deserializeBoolean(srcStart, srcEnd);
     } else if (isInteger<T>()) {
-      return deserializeInteger_Safe<T>(data);
+      return deserializeInteger<T>(srcStart, srcEnd);
     } else if (isFloat<T>()) {
-      return deserializeFloat<T>(data);
-    } else if (isNullable<T>() && data.length === 4 && data == "null") {
-      // @ts-ignore
-      return null;
+      return deserializeFloat<T>(srcStart, srcEnd);
     } else if (isString<T>()) {
-      // @ts-ignore
-      return deserializeString_Safe(data);
+      // @ts-ignore: type
+      return deserializeString(srcStart, srcEnd, dst);
     } else if (isArray<T>()) {
       // @ts-ignore
-      return deserializeArray_Safe<nonnull<T>>(data);
-    }
-    let type: nonnull<T> = changetype<nonnull<T>>(0);
-    // @ts-ignore: Defined by transform
-    if (isDefined(type.__DESERIALIZE)) {
-      // @ts-ignore
-      return deserializeObject_Safe<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Map) {
-      // @ts-ignore
-      return deserializeMap_Safe<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Date) {
-      // @ts-ignore
-      return deserializeDate_Safe(data);
+      return deserializeArray<T>(srcStart, srcEnd, dst);
     } else {
-      throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
+      let type: nonnull<T> = changetype<nonnull<T>>(0);
+      // @ts-ignore: declared by transform
+      if (isDefined(type.__DESERIALIZE)) {
+        return deserializeObject<T>(srcStart, srcEnd, dst);
+      } else if (type instanceof Map) {
+        // @ts-ignore: type
+        return deserializeMap<T>(srcStart, srcEnd, dst);
+      } else if (type instanceof Date) {
+        // @ts-ignore: type
+        return deserializeDate(srcStart, srcEnd);
+      }
     }
+    throw new Error(`Could not deserialize data '${ptrToStr(srcStart, srcEnd).slice(0, 100)}' to type. Make sure to add the correct decorators to classes.`);
   }
 }
-
-// This allows JSON.stringify and JSON.parse to be available globally through an alias
-// @ts-ignore: Decorator
-@global @inline function __SERIALIZE<T>(data: T): string {
-  return JSON.stringify(data);
-}
-// @ts-ignore: Decorator
-@global @inline function __DESERIALIZE<T>(data: string): T {
-  return JSON.parse<T>(data);
-}
-// @ts-ignore: Decorator
-@global @inline function __DESERIALIZE_SAFE<T>(data: string): T {
-  return JSON.parseSafe<T>(data);
-}

package/assembly/serialize/simd/string.ts

@@ -0,0 +1,176 @@
+import { bs } from "../../../modules/as-bs";
+import { BACK_SLASH } from "../../custom/chars";
+import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+
+const SPLAT_34 = i16x8.splat(34); /* " */
+const SPLAT_92 = i16x8.splat(92); /* \ */
+
+const SPLAT_32 = i16x8.splat(32); /* [ESC] */
+const SPLAT_0 = i16x8.splat(0); /* 0 */
+
+/**
+ * Serializes strings into their JSON counterparts using SIMD operations
+ * @param srcStart pointer to begin serializing at
+ * @param srcEnd pointer to end serialization at
+ */
+export function serializeString_SIMD(src: string): void {
+  const srcSize = changetype<OBJECT>(changetype<usize>(src) - TOTAL_OVERHEAD).rtSize;
+  let srcStart = changetype<usize>(src);
+  const srcEnd = srcStart + srcSize;
+  bs.ensureSize(srcSize + 4);
+  const srcEnd16 = srcEnd - 15;
+
+  store<u8>(changetype<usize>(bs.offset), 34); /* " */
+  bs.offset += 2;
+
+  while (srcStart < srcEnd16) {
+    const block = v128.load(srcStart);
+    v128.store(bs.offset, block);
+
+    const backslash_indices = i16x8.eq(block, SPLAT_92);
+    const quote_indices = i16x8.eq(block, SPLAT_34);
+    const escape_indices = i16x8.lt_u(block, SPLAT_32);
+    const sieve = v128.or(v128.or(backslash_indices, quote_indices), escape_indices);
+
+    let mask = i16x8.bitmask(sieve);
+
+    while (mask != 0) {
+      const lane_index = ctz(mask) << 1;
+      const dst_offset = bs.offset + lane_index;
+      const src_offset = srcStart + lane_index;
+      const code = load<u16>(src_offset) << 2;
+      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
+
+      mask &= mask - 1;
+
+      if ((escaped & 0xffff) != BACK_SLASH) {
+        bs.ensureSize(10);
+        store<u64>(dst_offset, 13511005048209500);
+        store<u32>(dst_offset, escaped, 8);
+        v128.store(dst_offset, v128.load(src_offset, 2), 12);
+        bs.offset += 10;
+      } else {
+        bs.ensureSize(2);
+        store<u32>(dst_offset, escaped);
+        v128.store(dst_offset, v128.load(src_offset, 2), 4);
+        bs.offset += 2;
+      }
+    }
+
+    srcStart += 16;
+    bs.offset += 16;
+  }
+
+  let rem = srcEnd - srcStart;
+
+  if (rem & 8) {
+    const block = v128.load64_zero(srcStart);
+    v128.store64_lane(bs.offset, block, 0);
+
+    const backslash_indices = i16x8.eq(block, SPLAT_92);
+    const quote_indices = i16x8.eq(block, SPLAT_34);
+    const escape_indices = i16x8.lt_u(block, SPLAT_32);
+    const zero_indices = i16x8.eq(block, SPLAT_0);
+    const sieve = v128.and(v128.or(v128.or(backslash_indices, quote_indices), escape_indices), v128.not(zero_indices));
+
+    let mask = i16x8.bitmask(sieve);
+    while (mask != 0) {
+      let lane_index = ctz(mask) << 1;
+      const dst_offset = bs.offset + lane_index;
+      const src_offset = srcStart + lane_index;
+      const code = load<u16>(src_offset) << 2;
+      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
+      mask &= mask - 1;
+
+      if ((escaped & 0xffff) != BACK_SLASH) {
+        bs.ensureSize(10);
+        store<u64>(dst_offset, 13511005048209500);
+        store<u32>(dst_offset, escaped, 8);
+        while (lane_index < 6) {
+          store<u8>(bs.offset + lane_index, load<u8>(srcStart + lane_index, 2), 12);
+          lane_index += 2;
+        }
+        bs.offset += 10;
+      } else {
+        bs.ensureSize(2);
+        store<u32>(dst_offset, escaped);
+
+        while (lane_index < 6) {
+          store<u8>(bs.offset + lane_index, load<u8>(srcStart + lane_index, 2), 4);
+          lane_index += 2;
+        }
+        bs.offset += 2;
+      }
+    }
+
+    bs.offset += 8;
+    srcStart += 8;
+  }
+  if (rem & 4) {
+    const block = load<u32>(srcStart);
+    const codeA = block & 0xffff;
+    const codeB = (block >> 16) & 0xffff;
+
+    if (codeA == 92 || codeA == 34 || codeA < 32) {
+      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeA << 2));
+
+      if ((escaped & 0xffff) != BACK_SLASH) {
+        bs.ensureSize(10);
+        store<u64>(bs.offset, 13511005048209500);
+        store<u32>(bs.offset, escaped, 8);
+        bs.offset += 12;
+      } else {
+        bs.ensureSize(2);
+        store<u32>(bs.offset, escaped);
+        bs.offset += 4;
+      }
+    } else {
+      store<u16>(bs.offset, codeA);
+      bs.offset += 2;
+    }
+
+    if (codeB == 92 || codeB == 34 || codeB < 32) {
+      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeB << 2));
+
+      if ((escaped & 0xffff) != BACK_SLASH) {
+        bs.ensureSize(10);
+        store<u64>(bs.offset, 13511005048209500);
+        store<u32>(bs.offset, escaped, 8);
+        bs.offset += 12;
+      } else {
+        bs.ensureSize(2);
+        store<u32>(bs.offset, escaped);
+        bs.offset += 4;
+      }
+    } else {
+      store<u16>(bs.offset, codeB);
+      bs.offset += 2;
+    }
+
+    srcStart += 4;
+  }
+  if (rem & 2) {
+    const code = load<u16>(srcStart);
+    if (code == 92 || code == 34 || code < 32) {
+      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
+
+      if ((escaped & 0xffff) != BACK_SLASH) {
+        bs.ensureSize(10);
+        store<u64>(bs.offset, 13511005048209500);
+        store<u32>(bs.offset, escaped, 8);
+        bs.offset += 12;
+      } else {
+        bs.ensureSize(2);
+        store<u32>(bs.offset, escaped);
+        bs.offset += 4;
+      }
+    } else {
+      store<u16>(bs.offset, code);
+      bs.offset += 2;
+    }
+  }
+
+  store<u8>(bs.offset, 34); /* " */
+  bs.offset += 2;
+}