json-as 0.9.29 → 1.0.0-alpha.1

package/transform/lib/index.js

@@ -1,440 +1,490 @@
-import { FieldDeclaration, IdentifierExpression, StringLiteralExpression, IntegerLiteralExpression, FloatLiteralExpression, NullExpression, TrueExpression, FalseExpression } from "assemblyscript/dist/assemblyscript.js";
-import { toString, isStdlib } from "visitor-as/dist/utils.js";
-import { BaseVisitor, SimpleParser } from "visitor-as/dist/index.js";
+import { IdentifierExpression, Source, StringLiteralExpression, IntegerLiteralExpression, FloatLiteralExpression, NullExpression, TrueExpression, FalseExpression, Node, Tokenizer } from "assemblyscript/dist/assemblyscript.js";
 import { Transform } from "assemblyscript/dist/transform.js";
-class JSONTransform extends BaseVisitor {
-    schemasList = [];
-    currentClass;
+import { Visitor } from "./visitor.js";
+import { SimpleParser, toString } from "./util.js";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { Property, PropertyFlags, Schema } from "./types.js";
+import { getClasses, getImportedClass } from "./linker.js";
+let indent = "  ";
+class JSONTransform extends Visitor {
+    parser;
+    schemas = [];
+    schema;
     sources = new Set();
-    visitMethodDeclaration() { }
+    imports = [];
+    jsonImport = null;
+    bsImport = null;
+    newStmts = { simd: [] };
     visitClassDeclaration(node) {
         if (!node.decorators?.length)
             return;
-        let found = false;
-        for (const decorator of node.decorators) {
+        if (!node.decorators.some((decorator) => {
             const name = decorator.name.text;
-            if (name === "json" || name === "serializable") {
-                found = true;
-                break;
-            }
-        }
-        if (!found)
+            return name === "json" || name === "serializable";
+        }))
             return;
-        const schema = new SchemaData();
-        schema.node = node;
-        schema.name = node.name.text;
-        const members = [...node.members.filter((v) => v.kind === 54)];
+        this.schema = new Schema();
+        this.schema.node = node;
+        this.schema.name = node.name.text;
+        this.schemas.push(this.schema);
+        if (process.env["JSON_DEBUG"])
+            console.log("Created schema: " + this.schema.name);
+        const members = [...node.members.filter((v) => v.kind === 54 && v.flags !== 32 && v.flags !== 512 && v.flags !== 1024 && !v.decorators?.some((decorator) => decorator.name.text === "omit"))];
         if (node.extendsType) {
-            schema.parent = this.schemasList.find((v) => v.name == node.extendsType?.name.identifier.text);
-            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);
+            const extendsName = node.extendsType?.name.identifier.text;
+            this.schema.parent = this.schemas.find((v) => v.name == extendsName);
+            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");
+                    this.visitClassDeclaration(internalSearch);
+                    this.visitClassDeclaration(node);
+                    return;
+                }
+                const externalSearch = getImportedClass(extendsName, node.range.source, this.parser);
+                if (externalSearch) {
+                    if (process.env["JSON_DEBUG"])
+                        console.log("Found " + extendsName + " externally");
+                    this.visitClassDeclaration(externalSearch);
+                    this.visitClassDeclaration(node);
+                    return;
+                }
+            }
+            if (this.schema.parent?.members) {
+                for (let i = this.schema.parent.members.length - 1; i >= 0; i--) {
+                    const replace = this.schema.members.find((v) => v.name == this.schema.parent?.members[i]?.name);
                     if (!replace) {
-                        members.unshift(schema.parent?.members[i].node);
+                        members.unshift(this.schema.parent?.members[i].node);
                     }
                 }
             }
         }
         if (!members.length) {
-            let SERIALIZE_RAW_EMPTY = '__SERIALIZE(): string {\n  return "{}";\n}';
-            let INITIALIZE_EMPTY = "__INITIALIZE(): this {\n  return this;\n}";
-            let DESERIALIZE_EMPTY = "__DESERIALIZE(data: string, key_start: i32, key_end: i32, value_start: i32, value_end: i32): boolean {\n  return false;\n}";
-            if (process.env["JSON_DEBUG"]) {
-                console.log(SERIALIZE_RAW_EMPTY);
-                console.log(INITIALIZE_EMPTY);
-                console.log(DESERIALIZE_EMPTY);
-            }
-            const SERIALIZE_RAW_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_RAW_EMPTY, node);
-            const INITIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(INITIALIZE_EMPTY, node);
-            const DESERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(DESERIALIZE_EMPTY, node);
-            if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
-                node.members.push(SERIALIZE_RAW_METHOD_EMPTY);
-            if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
-                node.members.push(INITIALIZE_METHOD_EMPTY);
-            if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
-                node.members.push(DESERIALIZE_METHOD_EMPTY);
-            this.schemasList.push(schema);
+            this.generateEmptyMethods(node);
+            return;
         }
+        this.addRequiredImports(node);
         for (const member of members) {
-            const name = member.name;
-            if (!(member instanceof FieldDeclaration))
-                continue;
-            if (!member.type) {
-                throw new Error("Fields must be strongly typed! Found " + toString(member) + " at " + node.range.source.normalizedPath);
-            }
+            if (!member.type)
+                throwError("Fields must be strongly typed", node.range);
             const type = toString(member.type);
-            if (type.startsWith("(") && type.includes("=>"))
-                continue;
+            const name = member.name;
             const value = member.initializer ? toString(member.initializer) : null;
-            if (member.flags == 32)
-                continue;
-            if (member.flags === 512)
-                continue;
-            if (member.flags === 1024)
-                continue;
-            if (member.decorators && node.decorators.some((v) => v.name.text == "omit"))
+            if (type.startsWith("(") && type.includes("=>"))
                 continue;
             const mem = new Property();
             mem.name = name.text;
             mem.type = type;
             mem.value = value;
             mem.node = member;
-            if (type.includes("JSON.Raw")) {
-                mem.flags.set(PropertyFlags.JSON_Raw, []);
-            }
-            if (member.type.isNullable) {
-                mem.flags.set(PropertyFlags.Null, []);
-            }
+            mem.byteSize = sizeof(mem.type);
+            this.schema.byteSize += mem.byteSize;
+            if (type.includes("JSON.Raw"))
+                mem.flags.set(PropertyFlags.Raw, null);
             if (member.decorators) {
                 for (const decorator of member.decorators) {
-                    const decoratorName = decorator.name.text;
-                    const args = getArgs(decorator.args);
+                    const decoratorName = decorator.name.text.toLowerCase().trim();
                     switch (decoratorName) {
                         case "alias": {
+                            const args = getArgs(decorator.args);
                             if (!args.length)
-                                throw new Error("Expected 1 argument but got zero at @alias in " + node.range.source.normalizedPath);
+                                throwError("@alias must have an argument of type string or number", member.range);
                             mem.alias = args[0];
-                            mem.flags.set(PropertyFlags.Alias, args);
-                            break;
-                        }
-                        case "omit": {
-                            mem.flags.set(PropertyFlags.Omit, args);
                             break;
                         }
                         case "omitif": {
+                            let arg = decorator.args[0];
                             if (!decorator.args?.length)
-                                throw new Error("Expected 1 argument but got zero at @omitif in " + node.range.source.normalizedPath);
-                            mem.flags.set(PropertyFlags.OmitIf, args);
+                                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": {
-                            mem.flags.set(PropertyFlags.OmitNull, args);
+                            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;
                         }
                     }
                 }
             }
-            mem.generate(false);
-            if (this.schemasList.find((v) => v.name == type)) {
-                mem.initialize = "this." + name.text + " = changetype<nonnull<" + mem.type + ">>(__new(offsetof<nonnull<" + mem.type + ">>(), idof<nonnull<" + mem.type + ">>()));\n  changetype<nonnull<" + mem.type + ">>(this." + name.text + ").__INITIALIZE()";
-            }
-            else if (mem.value) {
-                mem.initialize = "this." + name.text + " = " + mem.value;
-            }
-            else if (type === "Map") {
-                mem.initialize = "this." + name.text + " = new " + mem.type + "()";
-            }
-            else if (type === "string") {
-                mem.initialize = "this." + name.text + ' = ""';
-            }
-            else if (type === "Array") {
-                mem.initialize = "this." + name.text + " = instantiate<" + mem.type + ">()";
-            }
-            else if (type === "bool" || type === "boolean") {
-                mem.initialize = "this." + name.text + " = false";
-            }
-            else if (type === "JSON.Raw") {
-                mem.initialize = "this." + name.text + ' = ""';
-            }
-            else if (type === "u8" || type === "u16" || type === "u32" || type === "u64" || type === "i8" || type === "i16" || type === "i32" || type === "i64") {
-                mem.initialize = "this." + name.text + " = 0";
-            }
-            else if (type === "f32" || type === "f64") {
-                mem.initialize = "this." + name.text + " = 0.0";
-            }
-            schema.members.push(mem);
-        }
-        let SERIALIZE_RAW = "__SERIALIZE(): string {\n  let out = `{";
-        let SERIALIZE_PRETTY = "__SERIALIZE_PRETTY(): string {\n  let out = `{";
-        let INITIALIZE = "__INITIALIZE(): this {\n";
-        let DESERIALIZE = "__DESERIALIZE(data: string, key_start: i32, key_end: i32, value_start: i32, value_end: i32): boolean {\n  const len = key_end - key_start;\n";
-        let indent = "  ";
-        if (!schema.members.length)
-            return;
-        found = false;
-        if (schema.members[0]?.flags.has(PropertyFlags.OmitNull) || schema.members[0]?.flags.has(PropertyFlags.OmitIf)) {
-            SERIALIZE_RAW += schema.members[0]?.serialize;
-            SERIALIZE_PRETTY += "\\n" + schema.members[0]?.serialize;
+            this.schema.members.push(mem);
         }
-        else {
-            SERIALIZE_RAW += schema.members[0]?.serialize + ",";
-            SERIALIZE_PRETTY += "\\n" + schema.members[0]?.serialize + ",\\n";
-            found = true;
+        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 (keyEnd - keyStart) {\n";
+        let ALLOCATE = "@inline __ALLOCATE(): void {\n";
+        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";
         }
-        if (schema.members[0]?.initialize)
-            INITIALIZE += "  " + schema.members[0]?.initialize + ";\n";
-        for (let i = 1; i < schema.members.length; i++) {
-            const member = schema.members[i];
-            if (member.initialize)
-                INITIALIZE += "  " + member.initialize + ";\n";
-            if (member.flags.has(PropertyFlags.OmitNull) || member.flags.has(PropertyFlags.OmitIf)) {
-                SERIALIZE_RAW += member.serialize;
-                SERIALIZE_PRETTY += member.serialize;
+        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;
+            const nonNullType = member.type.replace(" | null", "");
+            if (member.value) {
+                INITIALIZE += `  this.${member.name} = ${member.value};\n`;
+            }
+            else if (this.schemas.find((v) => nonNullType == v.name)) {
+                INITIALIZE += `  this.${member.name} = changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE();\n`;
+            }
+            else if (member.type.startsWith("Array<") || member.type.startsWith("Map<")) {
+                INITIALIZE += `  this.${member.name} = [];\n`;
+            }
+            else if (member.type == "string" || member.type == "String" || member.type == "JSON.Raw") {
+                INITIALIZE += `  this.${member.name} = "";\n`;
+            }
+            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)
+                    .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)
+                    .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 {
-                SERIALIZE_RAW += member.serialize + ",";
-                SERIALIZE_PRETTY += indent + member.serialize + ",\\n";
-                found = true;
+                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)
+                        .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 == 14) {
+                        const arg = member.flags.get(PropertyFlags.OmitIf);
+                        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 + ":")
+                        .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`;
+                }
             }
         }
-        if (found) {
-            SERIALIZE_RAW += "`;\n  store<u16>(changetype<usize>(out) + ((out.length - 1) << 1), 125);\n  return out;\n}";
-            SERIALIZE_PRETTY += "`;\n  store<u32>(changetype<usize>(out) + ((out.length - 2) << 1), 8192010);\n  return out;\n}";
-        }
-        else {
-            SERIALIZE_RAW += "}`;\n  return out;\n}";
-            SERIALIZE_PRETTY += "}`;\n  return out;\n}";
-        }
-        INITIALIZE += "  return this;\n}";
-        const sortedMembers = [];
-        const _sorted = schema.members.sort((a, b) => (a.alias?.length || a.name.length) - (b.alias?.length || b.name.length));
+        let sortedMembers = [];
         let len = -1;
-        let offset = -1;
-        for (let i = 0; i < _sorted.length; i++) {
-            const member = _sorted[i];
-            const _name = member.alias || member.name;
-            if (_name.length === len) {
-                sortedMembers[offset]?.push(member);
+        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 = _name.length;
-                offset++;
-            }
-        }
-        let first = true;
-        for (const memberSet of sortedMembers) {
-            const firstMember = memberSet[0];
-            const _name = encodeKey(firstMember.alias || firstMember.name);
-            if (_name.length === 1) {
-                if (first) {
-                    DESERIALIZE += "  if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
-                }
+                len = _nameLength;
             }
-            else if (_name.length === 2) {
-                if (first) {
-                    DESERIALIZE += "  if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
-                    first = false;
+        });
+        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 = (<u64>load<u32>(keyStart) << 16) | <u64>load<u16>(keyStart, 4);\n`;
+            else
+                DESERIALIZE += toMemCDecl(memberLen, indent);
+            for (let i = 0; i < memberGroup.length; i++) {
+                const member = memberGroup[i];
+                const memberName = member.alias || member.name;
+                if (memberLen == 2) {
+                    DESERIALIZE += `${indent}  case ${memberName.charCodeAt(0)}: { // ${memberName}\n`;
+                    DESERIALIZE += `${indent}    store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    DESERIALIZE += `${indent}    return;\n`;
+                    DESERIALIZE += `${indent}  }\n`;
                 }
-                else {
-                    DESERIALIZE += "else if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
+                else if (memberLen == 4) {
+                    DESERIALIZE += `${indent}  case ${toU32(memberName)}: { // ${memberName}\n`;
+                    DESERIALIZE += `${indent}    store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    DESERIALIZE += `${indent}    return;\n`;
+                    DESERIALIZE += `${indent}  }\n`;
                 }
-            }
-            else if (_name.length === 4) {
-                if (first) {
-                    DESERIALIZE += "  if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
-                    first = false;
+                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), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    DESERIALIZE += `${indent}  return;\n`;
+                    DESERIALIZE += `${indent}}${i < memberGroup.length - 1 ? " else " : "\n"}`;
                 }
                 else {
-                    DESERIALIZE += "else if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
+                    DESERIALIZE += i == 0 ? indent : "";
+                    DESERIALIZE += `if (${toMemCCheck(memberName)}) { // ${memberName}\n`;
+                    DESERIALIZE += `${indent}  store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    DESERIALIZE += `${indent}  return;\n`;
+                    DESERIALIZE += `${indent}}${i < memberGroup.length - 1 ? " else " : "\n"}`;
                 }
             }
-            else {
-                if (first) {
-                    DESERIALIZE += "  if (" + _name.length + " === len) {\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (" + _name.length + " === len) {\n";
-                }
+            if (memberLen < 6) {
+                DESERIALIZE += `${indent}}\n`;
             }
-            let f = true;
-            for (let i = 0; i < memberSet.length; i++) {
-                const member = memberSet[i];
-                if (!member.deserialize)
-                    continue;
-                const _name = encodeKey(member.alias || member.name);
-                if (_name.length === 1) {
-                    DESERIALIZE += `      case ${_name.charCodeAt(0)}: { /* ${_name} */\n        ${member.deserialize}\n        return true;\n      }\n`;
-                }
-                else if (_name.length === 2) {
-                    DESERIALIZE += `      case ${charCodeAt32(_name, 0)}: { /* ${_name} */\n        ${member.deserialize}\n        return true;\n      }\n`;
-                }
-                else if (_name.length === 4) {
-                    if (f) {
-                        f = false;
-                        DESERIALIZE += `    if (${charCodeAt64(_name, 0)} === code) { /* ${_name} */\n      ${member.deserialize}\n      return true;\n    }\n`;
-                    }
-                    else {
-                        DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + `else if (${charCodeAt64(_name, 0)} === code) {\n      ${member.deserialize}\n      return true;\n    }\n`;
-                    }
-                }
-                else {
-                    if (f) {
-                        f = false;
-                        DESERIALIZE += `    if (0 === memory.compare(changetype<usize>("${escapeQuote(escapeSlash(_name))}"), changetype<usize>(data) + (key_start << 1), ${_name.length << 1})) { /* ${_name} */\n      ${member.deserialize}\n      return true;\n    }\n`;
-                    }
-                    else {
-                        DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else if (0 === memory.compare(changetype<usize>("${escapeQuote(escapeSlash(_name))}"), changetype<usize>(data) + (key_start << 1), ${_name.length << 1})) { /* ${_name} */\n      ${member.deserialize}\n      return true;\n    }\n`;
-                    }
-                }
-            }
-            if (_name.length < 3) {
-                DESERIALIZE += `      default: {\n        return false;\n      }\n    }\n`;
-            }
-            else if (_name.length == 4) {
-                DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else {\n      return false;\n    }\n`;
-            }
-            else {
-                DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else {\n      return false;\n    }\n`;
-            }
-            DESERIALIZE += "  } ";
+            indentDec();
+            DESERIALIZE += `${indent}  return;\n`;
+            DESERIALIZE += `${indent}}\n`;
         }
-        DESERIALIZE += "\n  return false;\n}";
+        indentDec();
+        DESERIALIZE += `${indent}}\n`;
+        indentDec();
+        DESERIALIZE += `${indent}}\n`;
+        indent = "  ";
+        this.schema.byteSize += 2;
+        SERIALIZE += indent + "store<u16>(bs.offset, 125, 0); // }\n";
+        SERIALIZE += indent + "bs.offset += 2;\n";
+        SERIALIZE += "}";
+        ALLOCATE += indent + "bs.ensureSize(" + this.schema.byteSize + ");\n";
+        ALLOCATE += "}";
+        INITIALIZE += "  return this;\n";
+        INITIALIZE += "}";
         if (process.env["JSON_DEBUG"]) {
-            console.log(SERIALIZE_RAW);
+            console.log(SERIALIZE);
             console.log(INITIALIZE);
             console.log(DESERIALIZE);
+            console.log(ALLOCATE);
         }
-        const SERIALIZE_RAW_METHOD = SimpleParser.parseClassMember(SERIALIZE_RAW, node);
-        const DESERIALIZE_SAFE = DESERIALIZE.replaceAll("__DESERIALIZE", "__DESERIALIZE_SAFE");
+        const SERIALIZE_METHOD = SimpleParser.parseClassMember(SERIALIZE, node);
         const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
         const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE, node);
-        const DESERIALIZE_SAFE_METHOD = SimpleParser.parseClassMember(DESERIALIZE_SAFE, node);
+        const ALLOCATE_METHOD = SimpleParser.parseClassMember(ALLOCATE, node);
         if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
-            node.members.push(SERIALIZE_RAW_METHOD);
+            node.members.push(SERIALIZE_METHOD);
         if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
             node.members.push(INITIALIZE_METHOD);
         if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
             node.members.push(DESERIALIZE_METHOD);
-        if (!node.members.find((v) => v.name.text == "__DESERIALIZE_SAFE"))
-            node.members.push(DESERIALIZE_SAFE_METHOD);
-        this.schemasList.push(schema);
+        if (!node.members.find((v) => v.name.text == "__ALLOCATE"))
+            node.members.push(ALLOCATE_METHOD);
+        super.visitClassDeclaration(node);
+    }
+    generateEmptyMethods(node) {
+        let SERIALIZE_RAW_EMPTY = '@inline __SERIALIZE(ptr: usize = changetype<usize>(this)): string {\n  return "{}";\n}';
+        let SERIALIZE_BS_EMPTY = "@inline __SERIALIZE(ptr: usize: bool): void {\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 {\n  return false;\n}";
+        let ALLOCATE_EMPTY = "@inline __ALLOCATE(): void {\n  bs.ensureSize(4);\n}";
+        if (process.env["JSON_DEBUG"]) {
+            console.log(SERIALIZE_RAW_EMPTY);
+            console.log(SERIALIZE_BS_EMPTY);
+            console.log(INITIALIZE_EMPTY);
+            console.log(DESERIALIZE_EMPTY);
+            console.log(ALLOCATE_EMPTY);
+        }
+        const SERIALIZE_RAW_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_RAW_EMPTY, node);
+        const SERIALIZE_BS_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_BS_EMPTY, node);
+        const INITIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(INITIALIZE_EMPTY, node);
+        const DESERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(DESERIALIZE_EMPTY, node);
+        const ALLOCATE_METHOD_EMPTY = SimpleParser.parseClassMember(ALLOCATE_EMPTY, node);
+        if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
+            node.members.push(SERIALIZE_RAW_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
+            node.members.push(SERIALIZE_BS_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
+            node.members.push(INITIALIZE_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
+            node.members.push(DESERIALIZE_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__ALLOCATE"))
+            node.members.push(ALLOCATE_METHOD_EMPTY);
+    }
+    visitImportStatement(node) {
+        super.visitImportStatement(node);
+        const source = this.parser.sources.find((src) => src.internalPath == node.internalPath);
+        if (!source)
+            return;
+        if (source.statements.some((stmt) => stmt.kind === 59 && stmt.name.text === "JSON"))
+            this.imports.push(node);
     }
     visitSource(node) {
+        this.imports = [];
         super.visitSource(node);
-        if (!this.sources.has(node)) {
-            return;
+    }
+    addRequiredImports(node) {
+        if (!this.imports.find((i) => i.declarations.find((d) => d.foreignName.text == "bs"))) {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            let relativePath = path.relative(path.dirname(node.range.source.normalizedPath), path.resolve(__dirname, "../../modules/bs/index.ts"));
+            if (!relativePath.startsWith(".") && !relativePath.startsWith("/"))
+                relativePath = "./" + relativePath;
+            const txt = `import { bs } from "${relativePath}";`;
+            if (!this.jsonImport) {
+                this.jsonImport = txt;
+                if (process.env["JSON_DEBUG"])
+                    console.log("Added bs import: " + txt + "\n");
+            }
+        }
+        if (!this.imports.find((i) => i.declarations.find((d) => d.foreignName.text == "JSON"))) {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            let relativePath = path.relative(path.dirname(node.range.source.normalizedPath), path.resolve(__dirname, "../../assembly/index.ts"));
+            if (!relativePath.startsWith(".") && !relativePath.startsWith("/"))
+                relativePath = "./" + relativePath;
+            const txt = `import { JSON } from "${relativePath}";`;
+            if (!this.jsonImport) {
+                this.jsonImport = txt;
+                if (process.env["JSON_DEBUG"])
+                    console.log("Added json-as import: " + txt + "\n");
+            }
+        }
+    }
+    getStores(data, simd = true) {
+        const out = [];
+        const sizes = strToNum(data, simd);
+        let offset = 0;
+        for (const [size, num] of sizes) {
+            if (size == "v128") {
+                let index = this.newStmts.simd.findIndex((v) => v.includes(num));
+                let name = "SIMD_" + (index == -1 ? this.newStmts.simd.length : index);
+                if (index && !this.newStmts.simd.includes(`const ${name} = ${num};`))
+                    this.newStmts.simd.push(`const ${name} = ${num};`);
+                out.push("store<v128>(bs.offset, " + name + ", " + offset + "); // " + data.slice(offset >> 1, (offset >> 1) + 8));
+                offset += 16;
+            }
+            if (size == "u64") {
+                out.push("store<u64>(bs.offset, " + num + ", " + offset + "); // " + data.slice(offset >> 1, (offset >> 1) + 4));
+                offset += 8;
+            }
+            else if (size == "u32") {
+                out.push("store<u32>(bs.offset, " + num + ", " + offset + "); // " + data.slice(offset >> 1, (offset >> 1) + 2));
+                offset += 4;
+            }
+            else if (size == "u16") {
+                out.push("store<u16>(bs.offset, " + num + ", " + offset + "); // " + data.slice(offset >> 1, (offset >> 1) + 1));
+                offset += 2;
+            }
         }
+        out.push("bs.offset += " + offset + ";");
+        return out;
     }
 }
 export default class Transformer extends Transform {
     afterParse(parser) {
         const transformer = new JSONTransform();
-        const sources = parser.sources
-            .filter((source) => !isStdlib(source))
-            .sort((_a, _b) => {
+        const sources = parser.sources.sort((_a, _b) => {
             const a = _a.internalPath;
             const b = _b.internalPath;
-            if (a[0] === "~" && b[0] !== "~") {
+            if (a[0] == "~" && b[0] !== "~") {
                 return -1;
             }
-            else if (a[0] !== "~" && b[0] === "~") {
+            else if (a[0] !== "~" && b[0] == "~") {
                 return 1;
             }
             else {
                 return 0;
             }
         });
+        transformer.parser = parser;
         for (const source of sources) {
-            if (!isStdlib(source)) {
-                transformer.visit(source);
+            transformer.imports = [];
+            transformer.currentSource = source;
+            transformer.visit(source);
+            if (transformer.newStmts.simd) {
+                const tokenizer = new Tokenizer(new Source(0, source.normalizedPath, transformer.newStmts.simd.join("\n")));
+                parser.currentSource = tokenizer.source;
+                for (let i = 0; i < transformer.newStmts.simd.length; i++)
+                    source.statements.unshift(parser.parseTopLevelStatement(tokenizer));
+                parser.currentSource = source;
+                transformer.newStmts.simd = [];
+            }
+            if (transformer.jsonImport) {
+                const tokenizer = new Tokenizer(new Source(0, source.normalizedPath, transformer.jsonImport));
+                parser.currentSource = tokenizer.source;
+                source.statements.unshift(parser.parseTopLevelStatement(tokenizer));
+                parser.currentSource = source;
+                transformer.jsonImport = null;
+            }
+            if (transformer.bsImport) {
+                const tokenizer = new Tokenizer(new Source(0, source.normalizedPath, transformer.bsImport));
+                parser.currentSource = tokenizer.source;
+                source.statements.unshift(parser.parseTopLevelStatement(tokenizer));
+                parser.currentSource = source;
+                transformer.bsImport = null;
             }
         }
-        const schemas = transformer.schemasList;
+        const schemas = transformer.schemas;
         for (const schema of schemas) {
             if (schema.parent) {
-                const parent = schemas.find((v) => v.name === schema.parent?.name);
+                const parent = schemas.find((v) => v.name == schema.parent?.name);
                 if (!parent)
-                    throw new Error(`Class ${schema.name} extends its parent class ${schema.parent}, but ${schema.parent} does not include a @json or @serializable decorator! Add the decorator and rebuild.`);
+                    throwError(`Class ${schema.name} extends its parent class ${schema.parent}, but ${schema.parent} does not include a @json or @serializable decorator!`, schema.parent.node.range);
             }
         }
     }
 }
-var PropertyFlags;
-(function (PropertyFlags) {
-    PropertyFlags[PropertyFlags["Null"] = 0] = "Null";
-    PropertyFlags[PropertyFlags["Omit"] = 1] = "Omit";
-    PropertyFlags[PropertyFlags["OmitNull"] = 2] = "OmitNull";
-    PropertyFlags[PropertyFlags["OmitIf"] = 3] = "OmitIf";
-    PropertyFlags[PropertyFlags["Alias"] = 4] = "Alias";
-    PropertyFlags[PropertyFlags["JSON_Raw"] = 5] = "JSON_Raw";
-})(PropertyFlags || (PropertyFlags = {}));
-class Property {
-    name = "";
-    alias = null;
-    type = "";
-    value = null;
-    flags = new Map();
-    serialize = null;
-    deserialize = null;
-    initialize = null;
-    node;
-    right_s = "";
-    right_d = "";
-    generate(safe) {
-        const name = this.name;
-        const escapedName = escapeString(JSON.stringify(this.alias || this.name));
-        const type = this.type;
-        if (this.flags.has(PropertyFlags.Omit))
-            return;
-        if (this.flags.has(PropertyFlags.JSON_Raw)) {
-            if (this.flags.has(PropertyFlags.Null)) {
-                this.right_s = "(this." + name + ' || "null")';
-                this.right_d = "value_start === value_end - 4 && 30399761348886638 === load<u64>(changetype<usize>(data) + (value_start << 1)) ? null : data.substring(value_start, value_end)";
-            }
-            else {
-                this.right_s = "this." + name;
-                this.right_d = "data.substring(value_start, value_end);";
-            }
+function sortMembers(members) {
+    return members.sort((a, b) => {
+        const aMove = a.flags.has(PropertyFlags.OmitIf) || a.flags.has(PropertyFlags.OmitNull);
+        const bMove = b.flags.has(PropertyFlags.OmitIf) || b.flags.has(PropertyFlags.OmitNull);
+        if (aMove && !bMove) {
+            return -1;
         }
-        else {
-            this.right_s = "__SERIALIZE<" + type + ">(this." + name + ")";
-            this.right_d = (safe ? "__DESERIALIZE_SAFE" : "__DESERIALIZE") + "<" + type + ">(data.substring(value_start, value_end))";
-        }
-        if (this.flags.has(PropertyFlags.OmitIf)) {
-            const condition = this.flags.get(PropertyFlags.OmitIf)[0];
-            if (!condition)
-                throw new Error("Could not find condition when using decorator @omitif! Provide at least one condition");
-            this.serialize = "${" + condition + ' ? "" : \'' + escapedName + ":' + " + this.right_s + ' + ","}';
-            this.deserialize = "this." + name + " = " + this.right_d + ";";
-        }
-        else if (this.flags.has(PropertyFlags.OmitNull)) {
-            this.serialize = "${changetype<usize>(this." + name + ") == <usize>0" + ' ? "" : \'' + escapedName + ":' + " + this.right_s + ' + ","}';
-            this.deserialize = "this." + name + " = " + this.right_d + ";";
+        else if (!aMove && bMove) {
+            return 1;
         }
         else {
-            this.serialize = escapedName + ":${" + this.right_s + "}";
-            this.deserialize = "this." + name + " = " + this.right_d + ";";
+            return 0;
         }
-    }
-}
-class SchemaData {
-    name = "";
-    members = [];
-    parent = null;
-    node;
-}
-function charCodeAt32(data, offset) {
-    return (data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset);
-}
-function charCodeAt64(data, offset) {
-    if (offset + 3 >= data.length) {
-        throw new Error("The string must have at least 4 characters from the specified offset.");
-    }
-    const firstCharCode = BigInt(data.charCodeAt(offset));
-    const secondCharCode = BigInt(data.charCodeAt(offset + 1));
-    const thirdCharCode = BigInt(data.charCodeAt(offset + 2));
-    const fourthCharCode = BigInt(data.charCodeAt(offset + 3));
-    const u64Value = (fourthCharCode << 48n) | (thirdCharCode << 32n) | (secondCharCode << 16n) | firstCharCode;
-    return u64Value;
-}
-function encodeKey(key) {
-    const data = JSON.stringify(key);
-    return data.slice(1, data.length - 1);
-}
-function escapeString(data) {
-    return data.replace(/\\/g, "\\\\").replace(/\`/g, "\\`");
-}
-function escapeSlash(data) {
-    return data.replace(/\\/g, "\\\\").replace(/\`/g, "\\`");
-}
-function escapeQuote(data) {
-    return data.replace(/\"/g, '\\"');
+    });
 }
 function getArgs(args) {
     if (!args)
@@ -465,4 +515,119 @@ function getArgs(args) {
     }
     return out;
 }
+function toU16(data, offset = 0) {
+    return data.charCodeAt(offset + 0).toString();
+}
+function toU32(data, offset = 0) {
+    return ((data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset + 0)).toString();
+}
+function toU48(data, offset = 0) {
+    return ((BigInt(data.charCodeAt(offset + 2)) << 32n) | (BigInt(data.charCodeAt(offset + 1)) << 16n) | BigInt(data.charCodeAt(offset + 0))).toString();
+}
+function toU64(data, offset = 0) {
+    return ((BigInt(data.charCodeAt(offset + 3)) << 48n) | (BigInt(data.charCodeAt(offset + 2)) << 32n) | (BigInt(data.charCodeAt(offset + 1)) << 16n) | BigInt(data.charCodeAt(offset + 0))).toString();
+}
+function toMemCDecl(n, indent) {
+    let out = "";
+    let offset = 0;
+    let index = 0;
+    while (n >= 8) {
+        out += `${indent}const code${index++} = load<u64>(keyStart, ${offset});\n`;
+        offset += 8;
+        n -= 8;
+    }
+    while (n >= 4) {
+        out += `${indent}const code${index++} = load<u32>(keyStart, ${offset});\n`;
+        offset += 4;
+        n -= 4;
+    }
+    if (n == 1)
+        out += `${indent}const code${index++} = load<u16>(keyStart, ${offset});\n`;
+    return out;
+}
+function toMemCCheck(data) {
+    let n = data.length << 1;
+    let out = "";
+    let offset = 0;
+    let index = 0;
+    while (n >= 8) {
+        out += ` && code${index++} == ${toU64(data, offset >> 1)}`;
+        offset += 8;
+        n -= 8;
+    }
+    while (n >= 4) {
+        out += ` && code${index++} == ${toU32(data, offset >> 1)}`;
+        offset += 4;
+        n -= 4;
+    }
+    if (n == 1)
+        out += ` && code${index++} == ${toU16(data, offset >> 1)}`;
+    return out.slice(4);
+}
+function strToNum(data, simd = false, offset = 0) {
+    const out = [];
+    let n = data.length;
+    while (n >= 8 && simd) {
+        out.push(["v128", "i16x8(" + data.charCodeAt(offset + 0) + ", " + data.charCodeAt(offset + 1) + ", " + data.charCodeAt(offset + 2) + ", " + data.charCodeAt(offset + 3) + ", " + data.charCodeAt(offset + 4) + ", " + data.charCodeAt(offset + 5) + ", " + data.charCodeAt(offset + 6) + ", " + data.charCodeAt(offset + 7) + ")"]);
+        offset += 8;
+        n -= 8;
+    }
+    while (n >= 4) {
+        const value = (BigInt(data.charCodeAt(offset + 3)) << 48n) | (BigInt(data.charCodeAt(offset + 2)) << 32n) | (BigInt(data.charCodeAt(offset + 1)) << 16n) | BigInt(data.charCodeAt(offset + 0));
+        out.push(["u64", value.toString()]);
+        offset += 4;
+        n -= 4;
+    }
+    while (n >= 2) {
+        const value = (data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset + 0);
+        out.push(["u32", value.toString()]);
+        offset += 2;
+        n -= 2;
+    }
+    if (n === 1) {
+        const value = data.charCodeAt(offset + 0);
+        out.push(["u16", value.toString()]);
+    }
+    return out;
+}
+function isPrimitive(type) {
+    const primitiveTypes = ["u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64", "f32", "f64", "bool", "boolean"];
+    return primitiveTypes.some((v) => type.includes(v));
+}
+function throwError(message, range) {
+    const err = new Error();
+    err.stack = `${message}\n  at ${range.source.normalizedPath}:${range.source.lineAt(range.start)}:${range.source.columnAt()}\n`;
+    throw err;
+}
+function indentInc() {
+    indent += "  ";
+}
+function indentDec() {
+    indent = indent.slice(0, Math.max(0, indent.length - 2));
+}
+function sizeof(type) {
+    if (type == "u8")
+        return 6;
+    else if (type == "i8")
+        return 8;
+    else if (type == "u16")
+        return 10;
+    else if (type == "i16")
+        return 12;
+    else if (type == "u32")
+        return 20;
+    else if (type == "i32")
+        return 22;
+    else if (type == "u64")
+        return 40;
+    else if (type == "i64")
+        return 40;
+    else if (type == "bool" || type == "boolean")
+        return 10;
+    else
+        return 0;
+}
+function allPrimitive(schema) {
+    return !schema.members.some((p) => p.byteSize == 0);
+}
 //# sourceMappingURL=index.js.map