json-as/transform/src/index.ts

The only JSON library you'll need for AssemblyScript. SIMD enabled

import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, CommonFlags, ImportStatement, Node, SourceKind, NamedTypeNode, Range, FunctionExpression, MethodDeclaration, Program, Feature } from "assemblyscript/dist/assemblyscript.js";
import { Transform } from "assemblyscript/dist/transform.js";
import { Visitor } from "./visitor.js";
import { isStdlib, removeExtension, SimpleParser, toString } from "./util.js";
import * as path from "path";
import { fileURLToPath } from "url";
import { Property, PropertyFlags, Schema, Src, SourceSet } from "./types.js";
import { readFileSync, writeFileSync } from "fs";
import { CustomTransform } from "./linkers/custom.js";

let indent = "  ";

let id = 0;

const WRITE = process.env["JSON_WRITE"]?.trim();
const rawValue = process.env["JSON_DEBUG"]?.trim();

const DEBUG = rawValue === "true" ? 1 : rawValue === "false" || rawValue === "" ? 0 : isNaN(Number(rawValue)) ? 0 : Number(rawValue);

const STRICT = process.env["JSON_STRICT"] && process.env["JSON_STRICT"] == "true";
export class JSONTransform extends Visitor {
  static SN: JSONTransform = new JSONTransform();

  public program!: Program;
  public baseCWD!: string;
  public parser!: Parser;
  public schemas: Map<string, Schema[]> = new Map<string, Schema[]>();
  public schema!: Schema;
  public sources: SourceSet = new SourceSet();
  public imports: ImportStatement[] = [];
  public simdStatements: string[] = [];

  private visitedClasses: Set<string> = new Set<string>();

  visitClassDeclarationRef(node: ClassDeclaration): void {
    if (
      !node.decorators?.length ||
      !node.decorators.some((decorator) => {
        const name = (<IdentifierExpression>decorator.name).text;
        return name === "json" || name === "serializable";
      })
    )
      throw new Error("Class " + node.name.text + " is missing an @json or @serializable decorator in " + node.range.source.internalPath);
    this.visitClassDeclaration(node);
  }

  visitClassDeclaration(node: ClassDeclaration): void {
    if (!node.decorators?.length) return;

    if (
      !node.decorators.some((decorator) => {
        const name = (<IdentifierExpression>decorator.name).text;
        return name === "json" || name === "serializable";
      })
    )
      return;

    const source = this.sources.get(node.range.source);

    const fullClassPath = source.getFullPath(node);

    if (this.visitedClasses.has(fullClassPath)) return;
    if (!this.schemas.has(source.internalPath)) this.schemas.set(source.internalPath, []);

    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[];
    const deserializers: MethodDeclaration[] = [...node.members.filter((v) => v.kind === NodeKind.MethodDeclaration && v.decorators && v.decorators.some((e) => (<IdentifierExpression>e.name).text.toLowerCase() === "deserializer"))] as MethodDeclaration[];

    const schema = new Schema();
    schema.node = node;
    schema.name = source.getQualifiedName(node);

    if (node.extendsType) {
      const extendsName = source.resolveExtendsName(node);

      if (!schema.parent) {
        const depSearch = schema.deps.find((v) => v.name == extendsName);
        if (depSearch) {
          if (DEBUG > 0) console.log("Found " + extendsName + " in dependencies of " + source.internalPath);
          if (!schema.deps.some((v) => v.name == depSearch.name)) schema.deps.push(depSearch);
          schema.parent = depSearch;
        } else {
          const internalSearch = source.getClass(extendsName);
          if (internalSearch) {
            if (DEBUG > 0) console.log("Found " + extendsName + " internally from " + source.internalPath);
            if (!this.visitedClasses.has(source.getFullPath(internalSearch))) {
              this.visitClassDeclarationRef(internalSearch);
              this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
              this.visitClassDeclaration(node);
              return;
            }
            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == extendsName);
            if (!schem) throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
            schema.deps.push(schem);
            schema.parent = schem;
          } else {
            const externalSearch = source.getImportedClass(extendsName, this.parser);
            if (externalSearch) {
              if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
              const externalSource = this.sources.get(externalSearch.range.source);
              if (!this.visitedClasses.has(externalSource.getFullPath(externalSearch))) {
                this.visitClassDeclarationRef(externalSearch);
                this.schemas.get(externalSource.internalPath).push(this.schema);
                this.visitClassDeclaration(node);
                return;
              }
              const schem = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == extendsName);
              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
              schema.deps.push(schem);
              schema.parent = schem;
            }
          }
        }
      }
      if (schema.parent?.members) {
        for (let i = schema.parent.members.length - 1; i >= 0; i--) {
          const replace = schema.members.find((v) => v.name == schema.parent?.members[i]?.name);
          if (!replace) {
            members.unshift(schema.parent?.members[i]!.node);
          }
        }
      }
    }

    const getUnknownTypes = (type: string, types: string[] = []): string[] => {
      type = stripNull(type);
      type = source.aliases.find((v) => stripNull(v.name) == type)?.getBaseType() || type;
      if (type.startsWith("Array<")) {
        return getUnknownTypes(type.slice(6, -1));
      } else if (type.startsWith("Map<")) {
        const parts = type.slice(4, -1).split(",");
        return getUnknownTypes(parts[0]) || getUnknownTypes(parts[1]);
      } else if (isString(type) || isPrimitive(type)) {
        return types;
      } else if (["JSON.Box", "JSON.Obj", "JSON.Value", "JSON.Raw"].includes(type)) {
        return types;
      } else if (node.isGeneric && node.typeParameters.some((p) => p.name.text == type)) {
        return types;
      } else if (type == node.name.text) {
        return types;
      }
      types.push(type);
      return types;
    };

    for (const member of members) {
      const type = toString(member.type);
      const unknown = getUnknownTypes(type);

      for (const unknownType of unknown) {
        const depSearch = schema.deps.find((v) => v.name == unknownType);
        if (depSearch) {
          if (DEBUG > 0) console.log("Found " + unknownType + " in dependencies of " + source.internalPath);
          if (!schema.deps.some((v) => v.name == depSearch.name)) {
            schema.deps.push(depSearch);
          }
        } else {
          const internalSearch = source.getClass(unknownType);
          if (internalSearch) {
            if (DEBUG > 0) console.log("Found " + unknownType + " internally from " + source.internalPath);
            if (!this.visitedClasses.has(source.getFullPath(internalSearch))) {
              this.visitClassDeclarationRef(internalSearch);
              const internalSchema = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == unknownType);
              // if (internalSchema.custom) mem.custom = true;
              schema.deps.push(internalSchema);
              this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
              this.visitClassDeclaration(node);
              return;
            }
            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == unknownType);
            if (!schem) throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
            schema.deps.push(schem);
          } else {
            const externalSearch = source.getImportedClass(unknownType, this.parser);
            if (externalSearch) {
              if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
              const externalSource = this.sources.get(externalSearch.range.source);
              if (!this.visitedClasses.has(externalSource.getFullPath(externalSearch))) {
                this.visitClassDeclarationRef(externalSearch);
                const externalSchema = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == unknownType);
                schema.deps.push(externalSchema);
                this.schemas.get(externalSource.internalPath).push(this.schema);
                this.visitClassDeclaration(node);
                return;
              }
              const schem = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == unknownType);
              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
              schema.deps.push(schem);
            }
          }
        }
      }
    }

    this.schemas.get(source.internalPath).push(schema);
    this.schema = schema;
    this.visitedClasses.add(fullClassPath);

    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 > 0) console.log("Created schema: " + this.schema.name + " in file " + source.normalizedPath + (this.schema.deps.length ? " with dependencies:\n  " + this.schema.deps.map((v) => v.name).join("\n  ") : ""));

    if (serializers.length > 1) throwError("Multiple serializers detected for class " + node.name.text + " but schemas can only have one serializer!", serializers[1].range);
    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];
      const hasCall = CustomTransform.hasCall(serializer);

      CustomTransform.visit(serializer);

      // 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);
      if (serializer.signature.parameters.length > 0 && (<NamedTypeNode>serializer.signature.parameters[0].type).name.identifier.text != node.name.text && (<NamedTypeNode>serializer.signature.parameters[0].type).name.identifier.text != "this") throwError("Type of parameter for custom serializer does not match! It should be 'string'either be 'this' or '" + this.schema.name + "'", serializer.signature.parameters[0].type.range);
      if (!serializer.signature.returnType || !(<NamedTypeNode>serializer.signature.returnType).name.identifier.text.includes("string")) throwError("Could not find valid return type for serializer in " + this.schema.name + "!. Set the return type to type 'string' and try again", serializer.signature.returnType.range);

      if (!serializer.decorators.some((v) => (<IdentifierExpression>v.name).text == "inline")) {
        serializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", serializer.range), null, serializer.range));
      }
      SERIALIZE_CUSTOM += "  __SERIALIZE(ptr: usize): void {\n";
      SERIALIZE_CUSTOM += "    const data = this." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "this" : "") + ");\n";
      if (hasCall) SERIALIZE_CUSTOM += "    bs.resetState();\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);
      if ((<NamedTypeNode>deserializer.signature.parameters[0].type).name.identifier.text != "string") throwError("Type of parameter for custom deserializer does not match! It must be 'string'", deserializer.signature.parameters[0].type.range);
      if (!deserializer.signature.returnType || !((<NamedTypeNode>deserializer.signature.returnType).name.identifier.text.includes(this.schema.name) || (<NamedTypeNode>deserializer.signature.returnType).name.identifier.text.includes("this"))) throwError("Could not find valid return type for deserializer in " + this.schema.name + "!. Set the return type to type '" + this.schema.name + "' or 'this' and try again", deserializer.signature.returnType.range);

      if (!deserializer.decorators.some((v) => (<IdentifierExpression>v.name).text == "inline")) {
        deserializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", deserializer.range), null, deserializer.range));
      }

      DESERIALIZE_CUSTOM += "  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
      DESERIALIZE_CUSTOM += "    return inline.always(this." + deserializer.name.text + "(JSON.Util.ptrToStr(srcStart, srcEnd)));\n";
      DESERIALIZE_CUSTOM += "  }\n";
    }

    if (!members.length && !deserializers.length && !serializers.length) {
      this.generateEmptyMethods(node);
      return;
    }

    for (const member of members) {
      if (!member.type) throwError("Fields must be strongly typed", node.range);
      let type = toString(member.type!);
      type = source.aliases.find((v) => stripNull(v.name) == stripNull(type))?.getBaseType() || type;

      const name = member.name;
      const value = member.initializer ? toString(member.initializer!) : null;

      // if (!this.isValidType(type, node)) throwError("Invalid Type. " + type + " is not a JSON-compatible type. Either decorate it with @omit, set it to private, or remove it.", member.type.range);

      if (type.startsWith("(") && type.includes("=>")) continue;

      const mem = new Property();
      mem.parent = this.schema;
      mem.name = name.text;
      mem.type = type;
      mem.value = value;
      mem.node = member;
      mem.byteSize = sizeof(mem.type);

      this.schema.byteSize += mem.byteSize;

      if (member.decorators) {
        for (const decorator of member.decorators) {
          const decoratorName = (decorator.name as IdentifierExpression).text.toLowerCase().trim();
          switch (decoratorName) {
            case "alias": {
              const arg = decorator.args[0];
              if (!arg || arg.kind != NodeKind.Literal) throwError("@alias must have an argument of type string or number", member.range);
              // @ts-ignore: exists
              mem.alias = arg.value.toString();
              break;
            }
            case "omitif": {
              let arg = decorator.args[0];
              if (!decorator.args?.length) throwError("@omitif must have an argument or callback that resolves to type bool", member.range);
              mem.flags.set(PropertyFlags.OmitIf, arg);
              this.schema.static = false;
              break;
            }
            case "omitnull": {
              if (isPrimitive(type)) {
                throwError("@omitnull cannot be used on primitive types!", member.range);
              } else if (!member.type.isNullable) {
                throwError("@omitnull cannot be used on non-nullable types!", member.range);
              }
              mem.flags.set(PropertyFlags.OmitNull, null);
              this.schema.static = false;
              break;
            }
          }
        }
      }

      this.schema.members.push(mem);
    }

    if (!this.schema.static) this.schema.members = sortMembers(this.schema.members);

    indent = "  ";

    if (this.schema.static == false) {
      if (this.schema.members.some((v) => v.flags.has(PropertyFlags.OmitNull))) {
        SERIALIZE += indent + "let block: usize = 0;\n";
      }
      this.schema.byteSize += 2;
      SERIALIZE += indent + "store<u16>(bs.offset, 123, 0); // {\n";
      SERIALIZE += indent + "bs.offset += 2;\n";
    }

    let isPure = this.schema.static;
    let isRegular = isPure;
    let isFirst = true;

    for (let i = 0; i < this.schema.members.length; i++) {
      const member = this.schema.members[i];
      const aliasName = JSON.stringify(member.alias || member.name);
      const realName = member.name;
      const isLast = i == this.schema.members.length - 1;

      if (member.value) {
        if (member.value != "null" && member.value != "0" && member.value != "0.0" && member.value != "false") {
          INITIALIZE += `  store<${member.type}>(changetype<usize>(this), ${member.value}, offsetof<this>(${JSON.stringify(member.name)}));\n`;
        }
      } else if (member.generic) {
        INITIALIZE += `  if (isManaged<nonnull<${member.type}>>() || isReference<nonnull<${member.type}>>()) {\n`;
        INITIALIZE += `    store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())), offsetof<this>(${JSON.stringify(member.name)}));\n`;
        INITIALIZE += `    if (isDefined(this.${member.name}.__INITIALIZE)) changetype<nonnull<${member.type}>>(this.${member.name}).__INITIALIZE();\n`;
        INITIALIZE += `  }\n`;
      } else if (!member.node.type.isNullable) {
        if (this.getSchema(member.type)) {
          INITIALIZE += `  store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
        } else if (member.type.startsWith("Array<") || member.type.startsWith("Map<")) {
          INITIALIZE += `  store<${member.type}>(changetype<usize>(this), [], offsetof<this>(${JSON.stringify(member.name)}));\n`;
        } else if (member.type == "string" || member.type == "String") {
          INITIALIZE += `  store<${member.type}>(changetype<usize>(this), "", offsetof<this>(${JSON.stringify(member.name)}));\n`;
        }
      }

      const SIMD_ENABLED = this.program.options.hasFeature(Feature.Simd);
      if (!isRegular && !member.flags.has(PropertyFlags.OmitIf) && !member.flags.has(PropertyFlags.OmitNull)) isRegular = true;
      if (isRegular && isPure) {
        const keyPart = (isFirst ? "{" : ",") + aliasName + ":";
        this.schema.byteSize += keyPart.length << 1;
        SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
          .map((v) => indent + v + "\n")
          .join("");
        SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
        if (isFirst) isFirst = false;
      } else if (isRegular && !isPure) {
        const keyPart = (isFirst ? "" : ",") + aliasName + ":";
        this.schema.byteSize += keyPart.length << 1;
        SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
          .map((v) => indent + v + "\n")
          .join("");
        SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
        if (isFirst) isFirst = false;
      } else {
        if (member.flags.has(PropertyFlags.OmitNull)) {
          SERIALIZE += indent + `if ((block = load<usize>(ptr, offsetof<this>(${JSON.stringify(realName)}))) !== 0) {\n`;
          indentInc();
          const keyPart = aliasName + ":";
          this.schema.byteSize += keyPart.length << 1;
          SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
            .map((v) => indent + v + "\n")
            .join("");
          SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;

          if (!isLast) {
            this.schema.byteSize += 2;
            SERIALIZE += indent + `store<u16>(bs.offset, 44, 0); // ,\n`;
            SERIALIZE += indent + `bs.offset += 2;\n`;
          }

          indentDec();
          this.schema.byteSize += 2;
          SERIALIZE += indent + `}\n`;
        } else if (member.flags.has(PropertyFlags.OmitIf)) {
          if (member.flags.get(PropertyFlags.OmitIf).kind == NodeKind.Function) {
            const arg = member.flags.get(PropertyFlags.OmitIf) as FunctionExpression;
            // @ts-ignore: type
            arg.declaration.signature.parameters[0].type = Node.createNamedType(Node.createSimpleTypeName("this", node.range), null, false, node.range);
            // @ts-ignore: type
            arg.declaration.signature.returnType.name = Node.createSimpleTypeName("boolean", arg.declaration.signature.returnType.name.range);
            SERIALIZE += indent + `if (!(${toString(member.flags.get(PropertyFlags.OmitIf))})(this)) {\n`;
          } else {
            SERIALIZE += indent + `if (${toString(member.flags.get(PropertyFlags.OmitIf))}) {\n`;
          }
          indentInc();
          SERIALIZE += this.getStores(aliasName + ":", SIMD_ENABLED)
            .map((v) => indent + v + "\n")
            .join("");
          SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;

          if (!isLast) {
            this.schema.byteSize += 2;
            SERIALIZE += indent + `store<u16>(bs.offset, 44, 0); // ,\n`;
            SERIALIZE += indent + `bs.offset += 2;\n`;
          }

          indentDec();
          SERIALIZE += indent + `}\n`;
        }
      }
    }

    const sortedMembers: {
      string: Property[];
      number: Property[];
      boolean: Property[];
      null: Property[];
      array: Property[];
      object: Property[];
    } = {
      string: [],
      number: [],
      boolean: [],
      null: [],
      array: [],
      object: [],
    };

    for (const member of this.schema.members) {
      const type = stripNull(member.type);
      if (member.custom || member.generic) {
        sortedMembers.string.push(member);
        sortedMembers.number.push(member);
        sortedMembers.object.push(member);
        sortedMembers.array.push(member);
        sortedMembers.boolean.push(member);
        sortedMembers.null.push(member);
      } else {
        if (member.node.type.isNullable) sortedMembers.null.push(member);
        if (isString(type) || type == "JSON.Raw") sortedMembers.string.push(member);
        else if (isBoolean(type) || type.startsWith("JSON.Box<bool")) sortedMembers.boolean.push(member);
        else if (isPrimitive(type) || type.startsWith("JSON.Box<") || isEnum(type, this.sources.get(this.schema.node.range.source), this.parser)) sortedMembers.number.push(member);
        else if (isArray(type)) sortedMembers.array.push(member);
        /*else if (isStruct(type)) */ sortedMembers.object.push(member);
        // else console.warn("Could not determine type " + type + " for member " + member.name + " in class " + this.schema.name);
      }
    }

    indent = "";

    DESERIALIZE += indent + "  let keyStart: usize = 0;\n";
    DESERIALIZE += indent + "  let keyEnd: usize = 0;\n";
    DESERIALIZE += indent + "  let isKey = false;\n";
    if (!STRICT || 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";
    DESERIALIZE += indent + "          keyEnd = srcStart;\n";
    if (DEBUG > 1) DESERIALIZE += indent + '          console.log("Key: " + JSON.Util.ptrToStr(keyStart, keyEnd));\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[]): Property[][] => {
      // const customMembers = this.schema.members.filter((m) => m.flags.has(PropertyFlags.Custom));
      // console.log("Custom members: ", customMembers.map((m) => m.name));

      // members.push(...customMembers)

      const groups = new Map<number, Property[]>();

      for (const member of members) {
        const name = member.alias || member.name;
        const length = name.length;

        if (!groups.has(length)) {
          groups.set(length, []);
        }

        groups.get(length)!.push(member);
      }

      return [...groups.values()]
        .map((group) =>
          group.sort((a, b) => {
            const aLen = (a.alias || a.name).length;
            const bLen = (b.alias || b.name).length;
            return aLen - bLen;
          }),
        )
        .sort((a, b) => b.length - a.length);
    };

    // const groupMembers = (members: Property[]): Property[][] => {
    //   const customMembers = this.schema.members.filter((m) =>
    //     m.flags.has(PropertyFlags.Custom)
    //   );
    //   console.log("Custom members: ", customMembers.map((m) => m.name));

    //   const customSet = new Set(customMembers);
    //   members = members.filter((m) => !customSet.has(m));
    //   members.push(...customMembers);

    //   const groups = new Map<number, Property[]>();

    //   for (const member of members) {
    //     const name = member.alias || member.name;
    //     const length = name.length;

    //     if (!groups.has(length)) {
    //       groups.set(length, []);
    //     }

    //     groups.get(length)!.push(member);
    //   }

    //   return [...groups.entries()]
    //     .sort(([a], [b]) => a - b)
    //     .map(([_, group]) => {
    //       const regulars = group.filter((m) => !customSet.has(m));
    //       const customs = group.filter((m) => customSet.has(m));

    //       const sortByLength = (a: Property, b: Property) =>
    //         (a.alias || a.name).length - (b.alias || b.name).length;

    //       return [...regulars.sort(sortByLength), ...customs.sort(sortByLength)];
    //     });
    // };

    const generateGroups = (members: Property[], cb: (group: Property[]) => void, type: "string" | "array" | "object" | "number" | "boolean" | "null") => {
      if (!members.length) {
        if (STRICT) {
          DESERIALIZE += indent + '              throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
        } else {
          if (type == "string") {
            DESERIALIZE += indent + "              srcStart += 4;\n";
          } else if (type == "boolean" || type == "null" || type == "number") {
            DESERIALIZE += indent + "              srcStart += 2;\n";
          }

          DESERIALIZE += indent + "              keyStart = 0;\n";
          if (type == "string" || type == "object" || type == "array" || type == "number") DESERIALIZE += indent + "              break;\n";
        }
      } else {
        const groups = groupMembers(members);
        DESERIALIZE += "     switch (<u32>keyEnd - <u32>keyStart) {\n";

        for (const group of groups) {
          const groupLen = (group[0].alias || group[0].name).length << 1;
          DESERIALIZE += "           case " + groupLen + ": {\n";
          cb(group);
          DESERIALIZE += "\n            }\n";
        }

        DESERIALIZE += "    default: {\n";
        if (STRICT) {
          DESERIALIZE += indent + '              throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
        } else {
          if (type == "string") {
            DESERIALIZE += indent + "              srcStart += 4;\n";
          } else if (type == "boolean" || type == "null" || type == "number") {
            DESERIALIZE += indent + "              srcStart += 2;\n";
          }
          DESERIALIZE += indent + "              keyStart = 0;\n";
          if (type == "string" || type == "object" || type == "array" || type == "number") DESERIALIZE += indent + "              break;\n";
        }
        DESERIALIZE += "        }\n";
        DESERIALIZE += "    }\n";
        if (type != "null" && type != "boolean") DESERIALIZE += "  break;\n";
      }
    };

    const generateConsts = (members: Property[]): void => {
      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)), "            ");
      }
    };

    let mbElse = "      ";
    if (!STRICT || sortedMembers.string.length) {
      // generateGroups(sortedMembers.string, generateComparisions)
      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";
      if (DEBUG > 1) DESERIALIZE += '              console.log("Value (string, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart + 2));';
      generateGroups(
        sortedMembers.string,
        (group) => {
          generateConsts(group);
          const first = group[0];
          const fName = first.alias || first.name;
          DESERIALIZE += indent + "            if (" + (first.generic ? "isString<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
          DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
          DESERIALIZE += indent + "              srcStart += 4;\n";
          DESERIALIZE += indent + "              keyStart = 0;\n";
          DESERIALIZE += indent + "              break;\n";
          DESERIALIZE += indent + "            }";

          for (let i = 1; i < group.length; i++) {
            const mem = group[i];
            const memName = mem.alias || mem.name;
            DESERIALIZE += indent + " else if (" + (mem.generic ? "isString<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
            DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
            DESERIALIZE += indent + "              srcStart += 4;\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }";
          }

          if (STRICT) {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + '              throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
            DESERIALIZE += indent + "            }\n";
          } else {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + "              srcStart += 4;\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }\n";
          }
        },
        "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 (!STRICT || 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";
      if (DEBUG > 1) DESERIALIZE += '              console.log("Value (number, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart));';
      // DESERIALIZE += "          console.log(JSON.Util.ptrToStr(keyStart,keyEnd) + \" = \" + load<u16>(keyStart).toString() + \" val \" + JSON.Util.ptrToStr(lastIndex, srcStart));\n";

      generateGroups(
        sortedMembers.number,
        (group) => {
          generateConsts(group);
          const first = group[0];
          const fName = first.alias || first.name;
          DESERIALIZE += indent + "            if (" + (first.generic ? "(isInteger<" + first.type + ">() || isFloat<" + first.type + ">()) && " : "") + getComparision(fName) + ") { // " + fName + "\n";
          DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
          DESERIALIZE += indent + "              srcStart += 2;\n";
          DESERIALIZE += indent + "              keyStart = 0;\n";
          DESERIALIZE += indent + "              break;\n";
          DESERIALIZE += indent + "            }";

          for (let i = 1; i < group.length; i++) {
            const mem = group[i];
            const memName = mem.alias || mem.name;
            DESERIALIZE += indent + " else if (" + (mem.generic ? "(isInteger<" + mem.type + ">() || isFloat<" + mem.type + ">()) && " : "") + getComparision(memName) + ") { // " + memName + "\n";
            DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
            DESERIALIZE += indent + "              srcStart += 2;\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }";
          }

          if (STRICT) {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + '              throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
            DESERIALIZE += indent + "            }\n";
          } else {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + "              srcStart += 2;\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }\n";
          }
        },
        "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 (!STRICT || 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";
      if (DEBUG > 1) DESERIALIZE += '              console.log("Value (object, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart));';

      indent = "  ";
      generateGroups(
        sortedMembers.object,
        (group) => {
          generateConsts(group);
          const first = group[0];
          const fName = first.alias || first.name;
          DESERIALIZE += indent + "            if (" + (first.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(fName) + ") { // " + fName + "\n";
          DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
          DESERIALIZE += indent + "              keyStart = 0;\n";
          DESERIALIZE += indent + "              break;\n";
          DESERIALIZE += indent + "            }";

          for (let i = 1; i < group.length; i++) {
            const mem = group[i];
            const memName = mem.alias || mem.name;
            DESERIALIZE += indent + " else if (" + (mem.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(memName) + ") { // " + memName + "\n";
            DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }";
          }

          if (STRICT) {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + '              throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
            DESERIALIZE += indent + "            }\n";
          } else {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }\n";
          }
        },
        "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 (!STRICT || 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";
      if (DEBUG > 1) DESERIALIZE += '              console.log("Value (object, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart));';

      indent = "  ";
      generateGroups(
        sortedMembers.array,
        (group) => {
          generateConsts(group);
          const first = group[0];
          const fName = first.alias || first.name;
          DESERIALIZE += indent + "            if (" + (first.generic ? "isArray<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
          DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
          DESERIALIZE += indent + "              keyStart = 0;\n";
          DESERIALIZE += indent + "              break;\n";
          DESERIALIZE += indent + "            }";

          for (let i = 1; i < group.length; i++) {
            const mem = group[i];
            const memName = mem.alias || mem.name;
            DESERIALIZE += indent + " else if (" + (mem.generic ? "isArray" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
            DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }";
          }

          if (STRICT) {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + '              throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
            DESERIALIZE += indent + "            }\n";
          } else {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }\n";
          }
        },
        "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 (!STRICT || sortedMembers.boolean.length) {
      // TRUE
      DESERIALIZE += mbElse + "if (code == 116) {\n";

      DESERIALIZE += "        if (load<u64>(srcStart) == 28429475166421108) {\n";
      DESERIALIZE += "          srcStart += 8;\n";
      if (DEBUG > 1) DESERIALIZE += '              console.log("Value (bool, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart - 8));';
      generateGroups(
        sortedMembers.boolean,
        (group) => {
          generateConsts(group);
          const first = group[0];
          const fName = first.alias || first.name;
          DESERIALIZE += indent + "          if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
          DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
          DESERIALIZE += indent + "            srcStart += 2;\n";
          DESERIALIZE += indent + "            keyStart = 0;\n";
          DESERIALIZE += indent + "            break;\n";
          DESERIALIZE += indent + "          }";

          for (let i = 1; i < group.length; i++) {
            const mem = group[i];
            const memName = mem.alias || mem.name;
            DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
            DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
            DESERIALIZE += indent + "            srcStart += 2;\n";
            DESERIALIZE += indent + "            keyStart = 0;\n";
            DESERIALIZE += indent + "            break;\n";
            DESERIALIZE += indent + "          }";
          }

          if (STRICT) {
            DESERIALIZE += " else {\n";
            DESERIALIZE += indent + '            throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
            DESERIALIZE += indent + "          }\n";
          } else {
            DESERIALIZE += " else { \n";
            DESERIALIZE += indent + "              srcStart += 2;\n";
            DESERIALIZE += indent + "              keyStart = 0;\n";
            DESERIALIZE += indent + "              break;\n";
            DESERIALIZE += indent + "            }\n";
          }
        },
        "boolean",
      );

      DESERIALIZE += "        }"; // Close first char check
      DESERIALIZE += " else {\n";
      DESERIALIZE += "          throw new Error(\"Expected to find 'true' but found '\" + JSON.Util.ptrToStr(lastIndex, srcStart) + \"' instead at position \" + (srcEnd - srcStart).toString());\n";
      DESERIALIZE += "        }"; // Close error check
      DESERIALIZE += "\n      }"; // Close first char check

      mbElse = " else ";

      // FALSE
      DESERIALIZE += mbElse + "if (code == 102) {\n";

      DESERIALIZE += "        if (load<u64>(srcStart, 2) == 28429466576093281) {\n";
      DESERIALIZE += "          srcStart += 10;\n";
      if (DEBUG > 1) DESERIALIZE += '              console.log("Value (bool, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart - 10));';
      generateGroups(
        sortedMembers.boolean,
        (group) => {
          generateConsts(group);

          const first = group[0];
          const fName = first.alias