json-as 1.0.8 → 1.1.0

package/transform/src/index.ts

@@ -1,4 +1,4 @@
-import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, CommonFlags, ImportStatement, Node, Tokenizer, SourceKind, NamedTypeNode, Range, FEATURE_SIMD, FunctionExpression, MethodDeclaration, Statement, Program } from "assemblyscript/dist/assemblyscript.js";
+import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, CommonFlags, ImportStatement, Node, Tokenizer, SourceKind, NamedTypeNode, Range, FEATURE_SIMD, FunctionExpression, MethodDeclaration, Statement, Program, Feature } from "assemblyscript/dist/assemblyscript.js";
 import { Transform } from "assemblyscript/dist/transform.js";
 import { Visitor } from "./visitor.js";
 import { isStdlib, SimpleParser, toString } from "./util.js";
@@ -6,11 +6,14 @@ import * as path from "path";
 import { fileURLToPath } from "url";
 import { Property, PropertyFlags, Schema } from "./types.js";
 import { getClasses, getImportedClass } from "./linker.js";
-import { Feature } from "types:assemblyscript/src/common";
 
 let indent = "  ";
 
+const DEBUG = process.env["JSON_DEBUG"];
+
 class JSONTransform extends Visitor {
+  static SN: JSONTransform = new JSONTransform();
+
   public program!: Program;
   public baseDir!: string;
   public parser!: Parser;
@@ -38,7 +41,14 @@ class JSONTransform extends Visitor {
     this.schema.name = node.name.text;
 
     this.schemas.push(this.schema);
-    if (process.env["JSON_DEBUG"]) console.log("Created schema: " + this.schema.name + " in file " + node.range.source.normalizedPath);
+
+    let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
+    let INITIALIZE = "@inline __INITIALIZE(): this {\n";
+    let DESERIALIZE = "__DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
+    let DESERIALIZE_CUSTOM = "";
+    let SERIALIZE_CUSTOM = "";
+
+    if (DEBUG) console.log("Created schema: " + this.schema.name + " in file " + node.range.source.normalizedPath);
 
     const members: FieldDeclaration[] = [...(node.members.filter((v) => v.kind === NodeKind.FieldDeclaration && v.flags !== CommonFlags.Static && v.flags !== CommonFlags.Private && v.flags !== CommonFlags.Protected && !v.decorators?.some((decorator) => (<IdentifierExpression>decorator.name).text === "omit")) as FieldDeclaration[])];
     const serializers: MethodDeclaration[] = [...node.members.filter((v) => v.kind === NodeKind.MethodDeclaration && v.decorators && v.decorators.some((e) => (<IdentifierExpression>e.name).text.toLowerCase() === "serializer"))] as MethodDeclaration[];
@@ -48,6 +58,7 @@ class JSONTransform extends Visitor {
     if (deserializers.length > 1) throwError("Multiple deserializers detected for class " + node.name.text + " but schemas can only have one deserializer!", deserializers[1].range);
 
     if (serializers.length) {
+      this.schema.custom = true;
       const serializer = serializers[0];
       // if (!serializer.signature.parameters.length) throwError("Could not find any parameters in custom serializer for " + this.schema.name + ". Serializers must have one parameter like 'serializer(self: " + this.schema.name + "): string {}'", serializer.range);
       if (serializer.signature.parameters.length > 1) throwError("Found too many parameters in custom serializer for " + this.schema.name + ", but serializers can only accept one parameter of type '" + this.schema.name + "'!", serializer.signature.parameters[1].range);
@@ -57,22 +68,16 @@ class JSONTransform extends Visitor {
       if (!serializer.decorators.some((v) => (<IdentifierExpression>v.name).text == "inline")) {
         serializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", serializer.range), null, serializer.range));
       }
-      let SERIALIZER = "";
-      SERIALIZER += "  __SERIALIZE_CUSTOM(): void {\n";
-      SERIALIZER += "    const data = this." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "this" : "") + ");\n";
-      SERIALIZER += "    const dataSize = data.length << 1;\n";
-      SERIALIZER += "    memory.copy(bs.offset, changetype<usize>(data), dataSize);\n";
-      SERIALIZER += "    bs.offset += dataSize;\n";
-      SERIALIZER += "  }\n";
-
-      if (process.env["JSON_DEBUG"]) console.log(SERIALIZER);
-
-      const SERIALIZER_METHOD = SimpleParser.parseClassMember(SERIALIZER, node);
-
-      if (!node.members.find((v) => v.name.text == "__SERIALIZE_CUSTOM")) node.members.push(SERIALIZER_METHOD);
+      SERIALIZE_CUSTOM += "  __SERIALIZE(ptr: usize): void {\n";
+      SERIALIZE_CUSTOM += "    const data = this." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "this" : "") + ");\n";
+      SERIALIZE_CUSTOM += "    const dataSize = data.length << 1;\n";
+      SERIALIZE_CUSTOM += "    memory.copy(bs.offset, changetype<usize>(data), dataSize);\n";
+      SERIALIZE_CUSTOM += "    bs.offset += dataSize;\n";
+      SERIALIZE_CUSTOM += "  }\n";
     }
 
     if (deserializers.length) {
+      this.schema.custom = true;
       const deserializer = deserializers[0];
       if (!deserializer.signature.parameters.length) throwError("Could not find any parameters in custom deserializer for " + this.schema.name + ". Deserializers must have one parameter like 'deserializer(data: string): " + this.schema.name + " {}'", deserializer.range);
       if (deserializer.signature.parameters.length > 1) throwError("Found too many parameters in custom deserializer for " + this.schema.name + ", but deserializers can only accept one parameter of type 'string'!", deserializer.signature.parameters[1].range);
@@ -82,16 +87,10 @@ class JSONTransform extends Visitor {
       if (!deserializer.decorators.some((v) => (<IdentifierExpression>v.name).text == "inline")) {
         deserializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", deserializer.range), null, deserializer.range));
       }
-      let DESERIALIZER = "";
-      DESERIALIZER += "  __DESERIALIZE_CUSTOM(data: string): this {\n";
-      DESERIALIZER += "    return this." + deserializer.name.text + "(data);\n";
-      DESERIALIZER += "  }\n";
-
-      if (process.env["JSON_DEBUG"]) console.log(DESERIALIZER);
 
-      const DESERIALIZER_METHOD = SimpleParser.parseClassMember(DESERIALIZER, node);
-
-      if (!node.members.find((v) => v.name.text == "__DESERIALIZE_CUSTOM")) node.members.push(DESERIALIZER_METHOD);
+      DESERIALIZE_CUSTOM += "  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
+      DESERIALIZE_CUSTOM += "    return inline.always(this." + deserializer.name.text + "(changetype<string>(srcStart)));\n";
+      DESERIALIZE_CUSTOM += "  }\n";
     }
 
     if (node.extendsType) {
@@ -100,7 +99,7 @@ class JSONTransform extends Visitor {
       if (!this.schema.parent) {
         const internalSearch = getClasses(node.range.source).find((v) => v.name.text == extendsName);
         if (internalSearch) {
-          if (process.env["JSON_DEBUG"]) console.log("Found " + extendsName + " internally");
+          if (DEBUG) console.log("Found " + extendsName + " internally");
           this.visitClassDeclaration(internalSearch);
           this.visitClassDeclaration(node);
           return;
@@ -108,7 +107,7 @@ class JSONTransform extends Visitor {
 
         const externalSearch = getImportedClass(extendsName, node.range.source, this.parser);
         if (externalSearch) {
-          if (process.env["JSON_DEBUG"]) console.log("Found " + extendsName + " externally");
+          if (DEBUG) console.log("Found " + extendsName + " externally");
           this.visitClassDeclaration(externalSearch);
           this.visitClassDeclaration(node);
           return;
@@ -187,10 +186,6 @@ class JSONTransform extends Visitor {
 
     if (!this.schema.static) this.schema.members = sortMembers(this.schema.members);
 
-    let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
-    let INITIALIZE = "@inline __INITIALIZE(): this {\n";
-    let DESERIALIZE = "__DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): void {\n  switch (<u32>keyEnd - <u32>keyStart) {\n";
-
     indent = "  ";
 
     if (this.schema.static == false) {
@@ -301,80 +296,352 @@ class JSONTransform extends Visitor {
       }
     }
 
-    let sortedMembers: Property[][] = [];
+    const sortedMembers: {
+      string: Property[];
+      number: Property[];
+      boolean: Property[];
+      null: Property[];
+      array: Property[];
+      object: Property[];
+    } = {
+      string: [],
+      number: [],
+      boolean: [],
+      null: [],
+      array: [],
+      object: [],
+    };
 
-    let len = -1;
-    this.schema.members
-      .slice()
-      .sort((a, b) => (a.alias?.length || a.name.length) - (b.alias?.length || b.name.length))
-      .forEach((member) => {
-        const _nameLength = member.alias?.length || member.name.length;
-        if (_nameLength === len) {
-          sortedMembers[sortedMembers.length - 1].push(member);
-        } else {
-          sortedMembers.push([member]);
-          len = _nameLength;
-        }
-      });
+    for (const member of this.schema.members) {
+      if (member.type.endsWith(" | null")) sortedMembers.null.push(member);
+      if (isString(member.type) || member.type == "JSON.Raw") sortedMembers.string.push(member);
+      else if (isBoolean(member.type) || member.type.startsWith("JSON.Box<bool")) sortedMembers.boolean.push(member);
+      else if (isPrimitive(member.type) || member.type.startsWith("JSON.Box<")) sortedMembers.number.push(member);
+      else if (isArray(member.type)) sortedMembers.array.push(member);
+      else sortedMembers.object.push(member);
+    }
+
+    indent = "";
+    let shouldGroup = false;
+
+    DESERIALIZE += indent + "  console.log(\"data: \" + JSON.Util.ptrToStr(srcStart,srcEnd))\n";
+    DESERIALIZE += indent + "  let keyStart: usize = 0;\n";
+    if (shouldGroup || DEBUG) DESERIALIZE += indent + "  let keyEnd: usize = 0;\n";
+    DESERIALIZE += indent + "  let isKey = false;\n";
+    if (sortedMembers.object.length || sortedMembers.array.length) DESERIALIZE += indent + "  let depth: i32 = 0;\n";
+    DESERIALIZE += indent + "  let lastIndex: usize = 0;\n\n";
+
+    DESERIALIZE += indent + "  while (srcStart < srcEnd && JSON.Util.isSpace(load<u16>(srcStart))) srcStart += 2;\n";
+    DESERIALIZE += indent + "  while (srcEnd > srcStart && JSON.Util.isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;\n";
+    DESERIALIZE += indent + '  if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");\n';
+    DESERIALIZE += indent + "  if (load<u16>(srcStart) != 123) throw new Error(\"Expected '{' at start of object at position \" + (srcEnd - srcStart).toString());\n";
+    DESERIALIZE += indent + "  if (load<u16>(srcEnd - 2) != 125) throw new Error(\"Expected '}' at end of object at position \" + (srcEnd - srcStart).toString());\n";
+    DESERIALIZE += indent + "  srcStart += 2;\n\n";
+
+    DESERIALIZE += indent + "  while (srcStart < srcEnd) {\n";
+    DESERIALIZE += indent + "    let code = load<u16>(srcStart);\n";
+    DESERIALIZE += indent + "    while (JSON.Util.isSpace(code)) code = load<u16>(srcStart += 2);\n";
+    DESERIALIZE += indent + "    if (keyStart == 0) {\n";
+    DESERIALIZE += indent + "      if (code == 34 && load<u16>(srcStart - 2) !== 92) {\n";
+    DESERIALIZE += indent + "        if (isKey) {\n";
+    DESERIALIZE += indent + "          keyStart = lastIndex;\n";
+    if (shouldGroup || DEBUG) DESERIALIZE += indent + "          keyEnd = srcStart;\n";
+    DESERIALIZE += indent + "          while (JSON.Util.isSpace((code = load<u16>((srcStart += 2))))) {}\n";
+    DESERIALIZE += indent + "          if (code !== 58) throw new Error(\"Expected ':' after key at position \" + (srcEnd - srcStart).toString());\n";
+    DESERIALIZE += indent + "          isKey = false;\n";
+    DESERIALIZE += indent + "        } else {\n";
+    DESERIALIZE += indent + "          isKey = true;\n";
+    DESERIALIZE += indent + "          lastIndex = srcStart + 2;\n";
+    DESERIALIZE += indent + "        }\n";
+    DESERIALIZE += indent + "      }\n";
+    DESERIALIZE += indent + "      srcStart += 2;\n";
+    DESERIALIZE += indent + "    } else {\n";
+    // if (shouldGroup) DESERIALIZE += "    const keySize = keyEnd - keyStart;\n";
+
+    const groupMembers = (members: Property[]) => {
+      let sorted: Property[][] = [];
+
+      let len = -1;
+      members
+        .slice()
+        .sort((a, b) => (a.alias?.length || a.name.length) - (b.alias?.length || b.name.length))
+        .forEach((member) => {
+          const _nameLength = member.alias?.length || member.name.length;
+          if (_nameLength === len) {
+            sorted[sorted.length - 1].push(member);
+          } else {
+            sorted.push([member]);
+            len = _nameLength;
+          }
+        });
+
+      sorted = sorted.sort((a, b) => b.length - a.length);
+      return sorted;
+    };
+
+    const generateComparisions = (members: Property[]) => {
+      if (members.some((m) => (m.alias || m.name).length << 1 == 2)) {
+        DESERIALIZE += "            const code16 = load<u16>(keyStart);\n";
+      }
+      if (members.some((m) => (m.alias || m.name).length << 1 == 4)) {
+        DESERIALIZE += "            const code32 = load<u32>(keyStart);\n";
+      }
+      if (members.some((m) => (m.alias || m.name).length << 1 == 6)) {
+        DESERIALIZE += "            const code48 = load<u64>(keyStart) & 0x0000FFFFFFFFFFFF;\n";
+      }
+      if (members.some((m) => (m.alias || m.name).length << 1 == 8)) {
+        DESERIALIZE += "            const code64 = load<u64>(keyStart);\n";
+      }
+      if (members.some((m) => (m.alias || m.name).length << 1 > 8)) {
+        DESERIALIZE += toMemCDecl(Math.max(...members.map((m) => (m.alias || m.name).length << 1)), "            ");
+      }
 
-    sortedMembers = sortedMembers.sort((a, b) => b.length - a.length);
-
-    indentInc();
-    for (const memberGroup of sortedMembers) {
-      const memberLen = (memberGroup[0].alias || memberGroup[0].name).length << 1;
-      DESERIALIZE += `${indent}case ${memberLen}: {\n`;
-      indentInc();
-      if (memberLen == 2) DESERIALIZE += `${indent}switch (load<u16>(keyStart)) {\n`;
-      else if (memberLen == 4) DESERIALIZE += `${indent}switch (load<u32>(keyStart)) {\n`;
-      else if (memberLen == 6) DESERIALIZE += `${indent}let code = load<u64>(keyStart) & 0x0000FFFFFFFFFFFF;\n`;
-      else if (memberLen == 8) DESERIALIZE += `${indent}let code = load<u64>(keyStart);\n`;
-      else DESERIALIZE += toMemCDecl(memberLen, indent);
-      for (let i = 0; i < memberGroup.length; i++) {
-        const member = memberGroup[i];
+      const complex = isStruct(members[0].type) || members[0].type != "JSON.Obj" || isArray(members[0].type);
+      const firstMemberName = members[0].alias || members[0].name;
+      DESERIALIZE += indent + "            if (" + getComparision(firstMemberName) + ") { // " + firstMemberName + "\n";
+      DESERIALIZE += indent + "              store<" + members[0].type + ">(changetype<usize>(out), JSON.__deserialize<" + members[0].type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(firstMemberName) + "));\n";
+      if (!complex) DESERIALIZE += indent + "              srcStart += 2;\n";
+      DESERIALIZE += indent + "              keyStart = 0;\n";
+      DESERIALIZE += indent + "              break;\n";
+      DESERIALIZE += indent + "            }";
+
+      for (let i = 1; i < members.length; i++) {
+        const member = members[i];
         const memberName = member.alias || member.name;
-        const dst = this.schemas.find((v) => v.name == member.type) ? 'load<usize>(ptr + offsetof<this>("' + member.name + '"))' : "0";
-        if (memberLen == 2) {
-          DESERIALIZE += `${indent}  case ${memberName.charCodeAt(0)}: { // ${memberName}\n`;
-          DESERIALIZE += `${indent}    store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd, ${dst}), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-          DESERIALIZE += `${indent}    return;\n`;
-          DESERIALIZE += `${indent}  }\n`;
-        } else if (memberLen == 4) {
-          DESERIALIZE += `${indent}  case ${toU32(memberName)}: { // ${memberName}\n`;
-          DESERIALIZE += `${indent}    store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd, ${dst}), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-          DESERIALIZE += `${indent}    return;\n`;
-          DESERIALIZE += `${indent}  }\n`;
-        } else if (memberLen == 6) {
-          DESERIALIZE += i == 0 ? indent : "";
-          DESERIALIZE += `if (code == ${toU48(memberName)}) { // ${memberName}\n`;
-          DESERIALIZE += `${indent}  store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd, ${dst}), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-          DESERIALIZE += `${indent}  return;\n`;
-          DESERIALIZE += `${indent}}${i < memberGroup.length - 1 ? " else " : "\n"}`;
-        } else if (memberLen == 8) {
-          DESERIALIZE += i == 0 ? indent : "";
-          DESERIALIZE += `if (code == ${toU64(memberName)}) { // ${memberName}\n`;
-          DESERIALIZE += `${indent}  store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd, ${dst}), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-          DESERIALIZE += `${indent}  return;\n`;
-          DESERIALIZE += `${indent}}${i < memberGroup.length - 1 ? " else " : "\n"}`;
-        } else {
-          DESERIALIZE += i == 0 ? indent : "";
-          DESERIALIZE += `if (${toMemCCheck(memberName)}) { // ${memberName}\n`;
-          DESERIALIZE += `${indent}  store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd, ${dst}), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-          DESERIALIZE += `${indent}  return;\n`;
-          DESERIALIZE += `${indent}}${i < memberGroup.length - 1 ? " else " : "\n"}`;
-        }
+        DESERIALIZE += indent + " else if (" + getComparision(memberName) + ") { // " + memberName + "\n";
+        DESERIALIZE += indent + "              store<" + members[0].type + ">(changetype<usize>(out), JSON.__deserialize<" + members[0].type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(memberName) + "));\n";
+        if (isString(members[0].type)) DESERIALIZE += indent + "              srcStart += 4;\n";
+        else if (!complex) DESERIALIZE += indent + "              srcStart += 2;\n";
+        DESERIALIZE += indent + "              keyStart = 0;\n";
+        DESERIALIZE += indent + "              break;\n";
+        DESERIALIZE += indent + "            }";
       }
-      if (memberLen < 6) {
-        DESERIALIZE += `${indent}}\n`; // Close switch
+
+      DESERIALIZE += " else {\n";
+      DESERIALIZE += indent + '              throw new Error("Unexpected key in JSON object \'" + String.fromCharCode(load<u16>(srcStart)) + "\' at position " + (srcEnd - srcStart).toString());\n';
+      DESERIALIZE += indent + "            }\n";
+    };
+
+    let mbElse = "      ";
+    if (sortedMembers.string.length) {
+      DESERIALIZE += mbElse + "if (code == 34) {\n";
+      DESERIALIZE += "          lastIndex = srcStart;\n";
+      DESERIALIZE += "          srcStart += 2;\n";
+      DESERIALIZE += "          while (srcStart < srcEnd) {\n";
+      DESERIALIZE += "            const code = load<u16>(srcStart);\n";
+      DESERIALIZE += "            if (code == 34 && load<u16>(srcStart - 2) !== 92) {\n";
+      DESERIALIZE += "              srcStart += 2;\n";
+      DESERIALIZE += "          console.log(JSON.Util.ptrToStr(keyStart,keyEnd) + \" = \" + load<u16>(keyStart).toString() + \" val \" + JSON.Util.ptrToStr(lastIndex, srcStart));\n";
+      generateComparisions(sortedMembers.string);
+      DESERIALIZE += "          }\n"; // Close break char check
+      DESERIALIZE += "          srcStart += 2;\n";
+      DESERIALIZE += "        }\n"; // Close char scan loop
+      DESERIALIZE += "      }\n"; // Close first char check
+      mbElse = " else ";
+    }
+
+    if (sortedMembers.number.length) {
+      DESERIALIZE += mbElse + "if (code - 48 <= 9 || code == 45) {\n";
+      DESERIALIZE += "        lastIndex = srcStart;\n";
+      DESERIALIZE += "        srcStart += 2;\n";
+      DESERIALIZE += "        while (srcStart < srcEnd) {\n";
+      DESERIALIZE += "          const code = load<u16>(srcStart);\n";
+      DESERIALIZE += "          if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {\n";
+      // DESERIALIZE += "          console.log(JSON.Util.ptrToStr(keyStart,keyEnd) + \" = \" + load<u16>(keyStart).toString() + \" val \" + JSON.Util.ptrToStr(lastIndex, srcStart));\n";
+
+      generateComparisions(sortedMembers.number);
+      DESERIALIZE += "          }\n"; // Close break char check
+      DESERIALIZE += "          srcStart += 2;\n";
+      DESERIALIZE += "        }\n"; // Close char scan loop
+      DESERIALIZE += "      }"; // Close first char check
+      mbElse = " else ";
+    }
+
+    if (sortedMembers.object.length) {
+      DESERIALIZE += mbElse + "if (code == 123) {\n";
+      DESERIALIZE += "        lastIndex = srcStart;\n";
+      DESERIALIZE += "        depth++;\n";
+      DESERIALIZE += "        srcStart += 2;\n";
+      DESERIALIZE += "        while (srcStart < srcEnd) {\n";
+      DESERIALIZE += "          const code = load<u16>(srcStart);\n";
+      DESERIALIZE += "          if (code == 34) {\n";
+      DESERIALIZE += "            srcStart += 2;\n";
+      DESERIALIZE += "            while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;\n";
+      DESERIALIZE += "          } else if (code == 125) {\n";
+      DESERIALIZE += "            if (--depth == 0) {\n";
+      DESERIALIZE += "              srcStart += 2;\n";
+
+      indent = "  ";
+      generateComparisions(sortedMembers.object);
+      indent = "";
+
+      DESERIALIZE += "            }\n"; // Close break char check
+      DESERIALIZE += "          } else if (code == 123) depth++;\n";
+      DESERIALIZE += "          srcStart += 2;\n";
+      DESERIALIZE += "        }\n"; // Close char scan loop
+      DESERIALIZE += "      }"; // Close first char check
+      mbElse = " else ";
+    }
+    if (sortedMembers.array.length) {
+      DESERIALIZE += mbElse + "if (code == 91) {\n";
+      DESERIALIZE += "        lastIndex = srcStart;\n";
+      DESERIALIZE += "        depth++;\n";
+      DESERIALIZE += "        srcStart += 2;\n";
+      DESERIALIZE += "        while (srcStart < srcEnd) {\n";
+      DESERIALIZE += "          const code = load<u16>(srcStart);\n";
+      DESERIALIZE += "          if (code == 34) {\n";
+      DESERIALIZE += "            srcStart += 2;\n";
+      DESERIALIZE += "            while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;\n";
+      DESERIALIZE += "          } else if (code == 93) {\n";
+      DESERIALIZE += "            if (--depth == 0) {\n";
+      DESERIALIZE += "              srcStart += 2;\n";
+      // DESERIALIZE += "          console.log(ptrToStr(keyStart,keyEnd) + \" = \" + (load<u64>(keyStart) & 0x0000FFFFFFFFFFFF) .toString());\n";
+
+      indent = "  ";
+      generateComparisions(sortedMembers.array);
+      indent = "";
+
+      DESERIALIZE += "            }\n"; // Close break char check
+      DESERIALIZE += "          } else if (code == 91) depth++;\n";
+      DESERIALIZE += "          srcStart += 2;\n";
+      DESERIALIZE += "        }\n"; // Close char scan loop
+      DESERIALIZE += "      }"; // Close first char check
+      mbElse = " else ";
+    }
+
+    if (sortedMembers.boolean.length) {
+      DESERIALIZE += mbElse + "if (code == 116) {\n";
+      DESERIALIZE += "        if (load<u64>(srcStart) == 28429475166421108) {\n";
+      DESERIALIZE += "          srcStart += 8;\n";
+      if (sortedMembers.boolean.some((m) => (m.alias || m.name).length << 1 == 2)) {
+        DESERIALIZE += "            const code16 = load<u16>(keyStart);\n";
+      }
+      if (sortedMembers.boolean.some((m) => (m.alias || m.name).length << 1 == 4)) {
+        DESERIALIZE += "            const code32 = load<u32>(keyStart);\n";
+      }
+      if (sortedMembers.boolean.some((m) => (m.alias || m.name).length << 1 == 6)) {
+        DESERIALIZE += "            const code48 = load<u64>(keyStart) & 0x0000FFFFFFFFFFFF;\n";
+      }
+      if (sortedMembers.boolean.some((m) => (m.alias || m.name).length << 1 == 8)) {
+        DESERIALIZE += "            const code64 = load<u64>(keyStart);\n";
+      }
+      if (sortedMembers.boolean.some((m) => (m.alias || m.name).length << 1 > 8)) {
+        DESERIALIZE += toMemCDecl(Math.max(...sortedMembers.boolean.map((m) => (m.alias || m.name).length << 1)), "            ");
+      }
+      const firstMemberName = sortedMembers.boolean[0].alias || sortedMembers.boolean[0].name;
+      DESERIALIZE += indent + "            if (" + getComparision(firstMemberName) + ") { // " + firstMemberName + "\n";
+      DESERIALIZE += indent + "              store<" + sortedMembers.boolean[0].type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(sortedMembers.boolean[0].name) + "));\n";
+      DESERIALIZE += indent + "              srcStart += 2;\n";
+      DESERIALIZE += indent + "              keyStart = 0;\n";
+      DESERIALIZE += indent + "              break;\n";
+      DESERIALIZE += indent + "            }";
+
+      for (let i = 1; i < sortedMembers.boolean.length; i++) {
+        const member = sortedMembers.boolean[i];
+        const memberName = member.alias || member.name;
+        DESERIALIZE += indent + " else if (" + getComparision(memberName) + ") { // " + memberName + "\n";
+        DESERIALIZE += indent + "            store<" + sortedMembers.boolean[0].type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(sortedMembers.boolean[0].name) + "));\n";
+        DESERIALIZE += indent + "            srcStart += 2;\n";
+        DESERIALIZE += indent + "            keyStart = 0;\n";
+        DESERIALIZE += indent + "            break;\n";
+        DESERIALIZE += indent + "          }";
       }
-      indentDec();
-      DESERIALIZE += `${indent}  return;\n`; // Break switch
-      DESERIALIZE += `${indent}}\n`; // Close length switch
+
+      DESERIALIZE += " else {\n";
+      DESERIALIZE += indent + '            throw new Error("Unexpected key in JSON object \'" + String.fromCharCode(load<u16>(srcStart)) + "\' at position " + (srcEnd - srcStart).toString());\n';
+      DESERIALIZE += indent + "          }\n";
+
+      DESERIALIZE += "        }"; // Close first char check
+      mbElse = " else ";
+      DESERIALIZE += " else if (load<u64>(srcStart, 2) == 28429466576093281) {\n";
+      DESERIALIZE += "          srcStart += 10;\n";
+
+      DESERIALIZE += indent + "          if (" + getComparision(firstMemberName) + ") { // " + firstMemberName + "\n";
+      DESERIALIZE += indent + "            store<" + sortedMembers.boolean[0].type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(sortedMembers.boolean[0].name) + "));\n";
+      DESERIALIZE += indent + "            srcStart += 2;\n";
+      DESERIALIZE += indent + "            keyStart = 0;\n";
+      DESERIALIZE += indent + "            break;\n";
+      DESERIALIZE += indent + "          }";
+
+      for (let i = 1; i < sortedMembers.boolean.length; i++) {
+        const member = sortedMembers.boolean[i];
+        const memberName = member.alias || member.name;
+        DESERIALIZE += indent + " else if (" + getComparision(memberName) + ") { // " + memberName + "\n";
+        DESERIALIZE += indent + "            store<" + sortedMembers.boolean[0].type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(sortedMembers.boolean[0].name) + "));\n";
+        DESERIALIZE += indent + "            srcStart += 2;\n";
+        DESERIALIZE += indent + "            keyStart = 0;\n";
+        DESERIALIZE += indent + "            break;\n";
+        DESERIALIZE += indent + "          }";
+      }
+
+      DESERIALIZE += " else {\n";
+      DESERIALIZE += indent + '            throw new Error("Unexpected key in JSON object \'" + String.fromCharCode(load<u16>(srcStart)) + "\' at position " + (srcEnd - srcStart).toString());\n';
+      DESERIALIZE += indent + "          }\n";
+
+      DESERIALIZE += "        }\n"; // Close first char check
+      DESERIALIZE += "      }"; // Close first char check
     }
 
+    if (sortedMembers.null.length) {
+      DESERIALIZE += mbElse + "if (code == 110) {\n";
+
+      DESERIALIZE += "        if (load<u64>(srcStart) == 30399761348886638) {\n";
+      DESERIALIZE += "          srcStart += 8;\n";
+
+      if (sortedMembers.null.some((m) => (m.alias || m.name).length << 1 == 2)) {
+        DESERIALIZE += "            const code16 = load<u16>(keyStart);\n";
+      }
+      if (sortedMembers.null.some((m) => (m.alias || m.name).length << 1 == 4)) {
+        DESERIALIZE += "            const code32 = load<u32>(keyStart);\n";
+      }
+      if (sortedMembers.null.some((m) => (m.alias || m.name).length << 1 == 6)) {
+        DESERIALIZE += "            const code48 = load<u64>(keyStart) & 0x0000FFFFFFFFFFFF;\n";
+      }
+      if (sortedMembers.null.some((m) => (m.alias || m.name).length << 1 == 8)) {
+        DESERIALIZE += "            const code64 = load<u64>(keyStart);\n";
+      }
+      if (sortedMembers.null.some((m) => (m.alias || m.name).length << 1 > 8)) {
+        DESERIALIZE += toMemCDecl(Math.max(...sortedMembers.null.map((m) => (m.alias || m.name).length << 1)), "            ");
+      }
+
+      const firstMemberName = sortedMembers.null[0].alias || sortedMembers.null[0].name;
+      DESERIALIZE += indent + "          if (" + getComparision(firstMemberName) + ") { // " + firstMemberName + "\n";
+      DESERIALIZE += indent + "            store<" + sortedMembers.null[0].type + ">(changetype<usize>(out), null, offsetof<this>(" + JSON.stringify(sortedMembers.null[0].name) + "));\n";
+      DESERIALIZE += indent + "            srcStart += 2;\n";
+      DESERIALIZE += indent + "            keyStart = 0;\n";
+      DESERIALIZE += indent + "            break;\n";
+      DESERIALIZE += indent + "          }";
+
+      for (let i = 1; i < sortedMembers.null.length; i++) {
+        const member = sortedMembers.null[i];
+        const memberName = member.alias || member.name;
+        DESERIALIZE += indent + " else if (" + getComparision(memberName) + ") { // " + memberName + "\n";
+        DESERIALIZE += indent + "            store<" + sortedMembers.null[0].type + ">(changetype<usize>(out), null, offsetof<this>(" + JSON.stringify(sortedMembers.null[0].name) + "));\n";
+        DESERIALIZE += indent + "            srcStart += 2;\n";
+        DESERIALIZE += indent + "            keyStart = 0;\n";
+        DESERIALIZE += indent + "            break;\n";
+        DESERIALIZE += indent + "          }";
+      }
+
+      DESERIALIZE += " else {\n";
+      DESERIALIZE += indent + '            throw new Error("Unexpected key in JSON object \'" + String.fromCharCode(load<u16>(srcStart)) + "\' at position " + (srcEnd - srcStart).toString());\n';
+      DESERIALIZE += indent + "          }\n";
+
+      DESERIALIZE += "        }"; // Close first char check
+      DESERIALIZE += "\n      }"; // Close first char check
+
+      mbElse = " else ";
+    }
+
+    DESERIALIZE += " else {\n";
+    DESERIALIZE += "   srcStart += 2;\n";
+    DESERIALIZE += "}\n";
+    DESERIALIZE += "\n    }\n"; // Close value portion
+
     indentDec();
-    DESERIALIZE += `${indent}}\n`; // Close length switch
+    DESERIALIZE += `  }\n`; // Close while loop
     indentDec();
-    DESERIALIZE += `${indent}}\n`; // Close function
+    DESERIALIZE += `  return out;\n}\n`; // Close function
 
     indent = "  ";
 
@@ -388,15 +655,18 @@ class JSONTransform extends Visitor {
     INITIALIZE += "  return this;\n";
     INITIALIZE += "}";
 
-    if (process.env["JSON_DEBUG"]) {
-      console.log(SERIALIZE);
+    // if (DESERIALIZE_CUSTOM) {
+    //   DESERIALIZE = "__DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): usize {\n  if (isDefined(this.__DESERIALIZE_CUSTOM) return changetype<usize>(this." + deserializers[0].name + "(changetype<switch (<u32>keyEnd - <u32>keyStart) {\n"
+    // }
+    if (DEBUG) {
+      console.log(SERIALIZE_CUSTOM ? SERIALIZE_CUSTOM : SERIALIZE);
       console.log(INITIALIZE);
-      console.log(DESERIALIZE);
+      console.log(DESERIALIZE_CUSTOM || DESERIALIZE);
     }
 
-    const SERIALIZE_METHOD = SimpleParser.parseClassMember(SERIALIZE, node);
+    const SERIALIZE_METHOD = SimpleParser.parseClassMember(SERIALIZE_CUSTOM ? SERIALIZE_CUSTOM : SERIALIZE, node);
     const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
-    const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE, node);
+    const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE_CUSTOM || DESERIALIZE, node);
 
     if (!node.members.find((v) => v.name.text == "__SERIALIZE")) node.members.push(SERIALIZE_METHOD);
     if (!node.members.find((v) => v.name.text == "__INITIALIZE")) node.members.push(INITIALIZE_METHOD);
@@ -406,9 +676,9 @@ class JSONTransform extends Visitor {
   generateEmptyMethods(node: ClassDeclaration): void {
     let SERIALIZE_EMPTY = "@inline __SERIALIZE(ptr: usize): void {\n  bs.proposeSize(4);\n  store<u32>(bs.offset, 8192123);\n  bs.offset += 4;\n}";
     let INITIALIZE_EMPTY = "@inline __INITIALIZE(): this {\n  return this;\n}";
-    let DESERIALIZE_EMPTY = "@inline __DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): void {}";
+    let DESERIALIZE_EMPTY = "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n  return this;\n}";
 
-    if (process.env["JSON_DEBUG"]) {
+    if (DEBUG) {
       console.log(SERIALIZE_EMPTY);
       console.log(INITIALIZE_EMPTY);
       console.log(DESERIALIZE_EMPTY);
@@ -474,7 +744,7 @@ class JSONTransform extends Visitor {
 
       const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("bs", node.range, false), null, node.range)], Node.createStringLiteralExpression(bsPath, node.range), node.range);
       this.topStatements.push(replaceNode);
-      if (process.env["JSON_DEBUG"]) console.log("Added as-bs import: " + toString(replaceNode) + "\n");
+      if (DEBUG) console.log("Added as-bs import: " + toString(replaceNode) + "\n");
     }
 
     if (!jsonImport) {
@@ -487,7 +757,7 @@ class JSONTransform extends Visitor {
         node.range,
       );
       this.topStatements.push(replaceNode);
-      if (process.env["JSON_DEBUG"]) console.log("Added json-as import: " + toString(replaceNode) + "\n");
+      if (DEBUG) console.log("Added json-as import: " + toString(replaceNode) + "\n");
     }
   }
 
@@ -536,7 +806,7 @@ class JSONTransform extends Visitor {
 
 export default class Transformer extends Transform {
   afterParse(parser: Parser): void {
-    const transformer = new JSONTransform();
+    const transformer = JSONTransform.SN;
     const sources = parser.sources
       .filter((source) => {
         const p = source.internalPath;
@@ -626,18 +896,18 @@ function toMemCDecl(n: number, indent: string): string {
   let offset = 0;
   let index = 0;
   while (n >= 8) {
-    out += `${indent}const code${index++} = load<u64>(keyStart, ${offset});\n`;
+    out += `${indent}const codeS${(index += 8)} = load<u64>(keyStart, ${offset});\n`;
     offset += 8;
     n -= 8;
   }
 
   while (n >= 4) {
-    out += `${indent}const code${index++} = load<u32>(keyStart, ${offset});\n`;
+    out += `${indent}const codeS${(index += 4)} = load<u32>(keyStart, ${offset});\n`;
     offset += 4;
     n -= 4;
   }
 
-  if (n == 1) out += `${indent}const code${index++} = load<u16>(keyStart, ${offset});\n`;
+  if (n == 1) out += `${indent}const codeS${(index += 1)} = load<u16>(keyStart, ${offset});\n`;
 
   return out;
 }
@@ -648,18 +918,18 @@ function toMemCCheck(data: string): string {
   let offset = 0;
   let index = 0;
   while (n >= 8) {
-    out += ` && code${index++} == ${toU64(data, offset >> 1)}`;
+    out += ` && codeS${(index += 8)} == ${toU64(data, offset >> 1)}`;
     offset += 8;
     n -= 8;
   }
 
   while (n >= 4) {
-    out += ` && code${index++} == ${toU32(data, offset >> 1)}`;
+    out += ` && codeS${(index += 4)} == ${toU32(data, offset >> 1)}`;
     offset += 4;
     n -= 4;
   }
 
-  if (n == 1) out += ` && code${index++} == ${toU16(data, offset >> 1)}`;
+  if (n == 1) out += ` && codeS${(index += 1)} == ${toU16(data, offset >> 1)}`;
 
   return out.slice(4);
 }
@@ -696,11 +966,6 @@ function strToNum(data: string, simd: boolean = false, offset: number = 0): stri
   return out;
 }
 
-function isPrimitive(type: string): boolean {
-  const primitiveTypes = ["u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64", "f32", "f64", "bool", "boolean"];
-  return primitiveTypes.some((v) => type.startsWith(v));
-}
-
 function throwError(message: string, range: Range): never {
   const err = new Error();
   err.stack = `${message}\n  at ${range.source.normalizedPath}:${range.source.lineAt(range.start)}:${range.source.columnAt()}\n`;
@@ -735,3 +1000,52 @@ function sizeof(type: string): number {
   else if (type == "bool" || type == "boolean") return 10;
   else return 0;
 }
+
+function isPrimitive(type: string): boolean {
+  const primitiveTypes = ["u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64", "f32", "f64", "bool", "boolean"];
+  return primitiveTypes.some((v) => type.startsWith(v));
+}
+
+function isBoolean(type: string): boolean {
+  return type == "bool" || type == "boolean";
+}
+
+function isStruct(type: string): boolean {
+  type = stripNull(type);
+  return JSONTransform.SN.schemas.some((v) => v.name == type) || JSONTransform.SN.schema.name == type;
+}
+
+function isString(type: string) {
+  return stripNull(type) == "string" || stripNull(type) == "String";
+}
+
+function isArray(type: string): boolean {
+  return type.startsWith("Array<");
+}
+
+function stripNull(type: string): string {
+  if (type.endsWith(" | null")) {
+    return type.slice(0, type.length - 7);
+  }
+  return type;
+}
+
+function getComparision(data: string) {
+  switch (data.length << 1) {
+    case 2: {
+      return "code16 == " + data.charCodeAt(0);
+    }
+    case 4: {
+      return "code32 == " + toU32(data);
+    }
+    case 6: {
+      return "code48 == " + toU48(data);
+    }
+    case 8: {
+      return "code64 == " + toU64(data);
+    }
+    default: {
+      return toMemCCheck(data);
+    }
+  }
+}