json-as 0.9.29 → 1.0.0-alpha.2

package/transform/lib/index.js

@@ -1,468 +1,573 @@
-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;
-    sources = new Set();
-    visitMethodDeclaration() { }
-    visitClassDeclaration(node) {
-        if (!node.decorators?.length)
-            return;
-        let found = false;
-        for (const decorator of node.decorators) {
-            const name = decorator.name.text;
-            if (name === "json" || name === "serializable") {
-                found = true;
-                break;
-            }
-        }
-        if (!found)
-            return;
-        const schema = new SchemaData();
-        schema.node = node;
-        schema.name = node.name.text;
-        const members = [...node.members.filter((v) => v.kind === 54)];
-        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);
-                    if (!replace) {
-                        members.unshift(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);
-        }
-        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);
-            }
-            const type = toString(member.type);
-            if (type.startsWith("(") && type.includes("=>"))
-                continue;
-            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"))
-                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, []);
-            }
-            if (member.decorators) {
-                for (const decorator of member.decorators) {
-                    const decoratorName = decorator.name.text;
-                    const args = getArgs(decorator.args);
-                    switch (decoratorName) {
-                        case "alias": {
-                            if (!args.length)
-                                throw new Error("Expected 1 argument but got zero at @alias in " + node.range.source.normalizedPath);
-                            mem.alias = args[0];
-                            mem.flags.set(PropertyFlags.Alias, args);
-                            break;
-                        }
-                        case "omit": {
-                            mem.flags.set(PropertyFlags.Omit, args);
-                            break;
-                        }
-                        case "omitif": {
-                            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);
-                            break;
-                        }
-                        case "omitnull": {
-                            mem.flags.set(PropertyFlags.OmitNull, args);
-                            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);
+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();
+  imports = [];
+  jsonImport = null;
+  bsImport = null;
+  newStmts = { simd: [] };
+  visitClassDeclaration(node) {
+    if (!node.decorators?.length) return;
+    if (
+      !node.decorators.some((decorator) => {
+        const name = decorator.name.text;
+        return name === "json" || name === "serializable";
+      })
+    )
+      return;
+    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) {
+      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;
         }
-        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;
+        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;
         }
-        else {
-            SERIALIZE_RAW += schema.members[0]?.serialize + ",";
-            SERIALIZE_PRETTY += "\\n" + schema.members[0]?.serialize + ",\\n";
-            found = true;
+      }
+      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(this.schema.parent?.members[i].node);
+          }
         }
-        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;
-            }
-            else {
-                SERIALIZE_RAW += member.serialize + ",";
-                SERIALIZE_PRETTY += indent + member.serialize + ",\\n";
-                found = true;
-            }
-        }
-        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}";
+      }
+    }
+    if (!members.length) {
+      this.generateEmptyMethods(node);
+      return;
+    }
+    this.addRequiredImports(node);
+    for (const member of members) {
+      if (!member.type) throwError("Fields must be strongly typed", node.range);
+      const type = toString(member.type);
+      const name = member.name;
+      const value = member.initializer ? toString(member.initializer) : null;
+      if (type.startsWith("(") && type.includes("=>")) continue;
+      const mem = new Property();
+      mem.name = name.text;
+      mem.type = type;
+      mem.value = value;
+      mem.node = member;
+      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.toLowerCase().trim();
+          switch (decoratorName) {
+            case "alias": {
+              const args = getArgs(decorator.args);
+              if (!args.length) throwError("@alias must have an argument of type string or number", member.range);
+              mem.alias = args[0];
+              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;
+            }
+          }
         }
-        else {
-            SERIALIZE_RAW += "}`;\n  return out;\n}";
-            SERIALIZE_PRETTY += "}`;\n  return out;\n}";
+      }
+      this.schema.members.push(mem);
+    }
+    if (!this.schema.static) this.schema.members = sortMembers(this.schema.members);
+    let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
+    let INITIALIZE = "@inline __INITIALIZE(): this {\n";
+    let DESERIALIZE = "__DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): void {\n  switch (<u32>keyEnd - <u32>keyStart) {\n";
+    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";
+    }
+    for (const member of this.schema.members) {
+      const nonNullType = member.type.replace(" | null", "");
+      if (!isPrimitive(nonNullType)) {
+        const schema = this.schemas.find((v) => v.name == nonNullType);
+        if (schema && !this.schema.deps.includes(schema)) {
+          this.schema.deps.push(schema);
+          this.schema.byteSize += schema.byteSize;
         }
-        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 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);
-            }
-            else {
-                sortedMembers.push([member]);
-                len = _name.length;
-                offset++;
-            }
+      }
+    }
+    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 {
+        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`;
         }
-        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";
-                }
-            }
-            else if (_name.length === 2) {
-                if (first) {
-                    DESERIALIZE += "  if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\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 {
-                    DESERIALIZE += "else if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
-                }
-            }
-            else {
-                if (first) {
-                    DESERIALIZE += "  if (" + _name.length + " === len) {\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (" + _name.length + " === len) {\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 += "  } ";
+      }
+    }
+    let sortedMembers = [];
+    let len = -1;
+    this.schema.members
+      .slice()
+      .sort((a, b) => (a.alias?.length || a.name.length) - (b.alias?.length || b.name.length))
+      .forEach((member) => {
+        const _nameLength = member.alias?.length || member.name.length;
+        if (_nameLength === len) {
+          sortedMembers[sortedMembers.length - 1].push(member);
+        } else {
+          sortedMembers.push([member]);
+          len = _nameLength;
         }
-        DESERIALIZE += "\n  return false;\n}";
-        if (process.env["JSON_DEBUG"]) {
-            console.log(SERIALIZE_RAW);
-            console.log(INITIALIZE);
-            console.log(DESERIALIZE);
+      });
+    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 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 (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 += 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"}`;
         }
-        const SERIALIZE_RAW_METHOD = SimpleParser.parseClassMember(SERIALIZE_RAW, node);
-        const DESERIALIZE_SAFE = DESERIALIZE.replaceAll("__DESERIALIZE", "__DESERIALIZE_SAFE");
-        const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
-        const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE, node);
-        const DESERIALIZE_SAFE_METHOD = SimpleParser.parseClassMember(DESERIALIZE_SAFE, node);
-        if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
-            node.members.push(SERIALIZE_RAW_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 (memberLen < 6) {
+        DESERIALIZE += `${indent}}\n`;
+      }
+      indentDec();
+      DESERIALIZE += `${indent}  return;\n`;
+      DESERIALIZE += `${indent}}\n`;
     }
-    visitSource(node) {
-        super.visitSource(node);
-        if (!this.sources.has(node)) {
-            return;
-        }
+    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);
+      console.log(INITIALIZE);
+      console.log(DESERIALIZE);
+      console.log(ALLOCATE);
     }
+    const SERIALIZE_METHOD = SimpleParser.parseClassMember(SERIALIZE, node);
+    const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
+    const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE, node);
+    const ALLOCATE_METHOD = SimpleParser.parseClassMember(ALLOCATE, node);
+    if (!node.members.find((v) => v.name.text == "__SERIALIZE")) node.members.push(SERIALIZE_METHOD);
+    if (!node.members.find((v) => v.name.text == "__INITIALIZE")) node.members.push(INITIALIZE_METHOD);
+    if (!node.members.find((v) => v.name.text == "__DESERIALIZE")) node.members.push(DESERIALIZE_METHOD);
+    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);
+  }
+  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/as-bs/"));
+      if (!relativePath.startsWith(".") && !relativePath.startsWith("/")) relativePath = "./" + relativePath;
+      const txt = `import { bs } from "${relativePath}";`;
+      if (!this.bsImport) {
+        this.bsImport = txt;
+        if (process.env["JSON_DEBUG"]) console.log("Added as-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 = false) {
+    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 a = _a.internalPath;
-            const b = _b.internalPath;
-            if (a[0] === "~" && b[0] !== "~") {
-                return -1;
-            }
-            else if (a[0] !== "~" && b[0] === "~") {
-                return 1;
-            }
-            else {
-                return 0;
-            }
-        });
-        for (const source of sources) {
-            if (!isStdlib(source)) {
-                transformer.visit(source);
-            }
-        }
-        const schemas = transformer.schemasList;
-        for (const schema of schemas) {
-            if (schema.parent) {
-                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.`);
-            }
-        }
+  afterParse(parser) {
+    const transformer = new JSONTransform();
+    const sources = parser.sources.sort((_a, _b) => {
+      const a = _a.internalPath;
+      const b = _b.internalPath;
+      if (a[0] == "~" && b[0] !== "~") {
+        return -1;
+      } else if (a[0] !== "~" && b[0] == "~") {
+        return 1;
+      } else {
+        return 0;
+      }
+    });
+    transformer.parser = parser;
+    for (const source of sources) {
+      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.schemas;
+    for (const schema of schemas) {
+      if (schema.parent) {
+        const parent = schemas.find((v) => v.name == schema.parent?.name);
+        if (!parent) 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);";
-            }
-        }
-        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 {
-            this.serialize = escapedName + ":${" + this.right_s + "}";
-            this.deserialize = "this." + name + " = " + this.right_d + ";";
-        }
+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 if (!aMove && bMove) {
+      return 1;
+    } else {
+      return 0;
     }
+  });
 }
-class SchemaData {
-    name = "";
-    members = [];
-    parent = null;
-    node;
+function getArgs(args) {
+  if (!args) return [];
+  let out = [];
+  for (const arg of args) {
+    if (arg instanceof StringLiteralExpression) {
+      out.push(arg.value);
+    } else if (arg instanceof IntegerLiteralExpression) {
+      out.push(i64_to_string(arg.value));
+    } else if (arg instanceof FloatLiteralExpression) {
+      out.push(arg.value.toString());
+    } else if (arg instanceof NullExpression) {
+      out.push(arg.text);
+    } else if (arg instanceof TrueExpression) {
+      out.push(arg.text);
+    } else if (arg instanceof FalseExpression) {
+      out.push(arg.text);
+    } else if (arg instanceof IdentifierExpression) {
+      out.push(arg.text);
+    }
+  }
+  return out;
 }
-function charCodeAt32(data, offset) {
-    return (data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset);
+function toU16(data, offset = 0) {
+  return data.charCodeAt(offset + 0).toString();
 }
-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 toU32(data, offset = 0) {
+  return ((data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset + 0)).toString();
 }
-function encodeKey(key) {
-    const data = JSON.stringify(key);
-    return data.slice(1, data.length - 1);
+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 escapeString(data) {
-    return data.replace(/\\/g, "\\\\").replace(/\`/g, "\\`");
+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 escapeSlash(data) {
-    return data.replace(/\\/g, "\\\\").replace(/\`/g, "\\`");
+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 escapeQuote(data) {
-    return data.replace(/\"/g, '\\"');
+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 getArgs(args) {
-    if (!args)
-        return [];
-    let out = [];
-    for (const arg of args) {
-        if (arg instanceof StringLiteralExpression) {
-            out.push(arg.value);
-        }
-        else if (arg instanceof IntegerLiteralExpression) {
-            out.push(i64_to_string(arg.value));
-        }
-        else if (arg instanceof FloatLiteralExpression) {
-            out.push(arg.value.toString());
-        }
-        else if (arg instanceof NullExpression) {
-            out.push(arg.text);
-        }
-        else if (arg instanceof TrueExpression) {
-            out.push(arg.text);
-        }
-        else if (arg instanceof FalseExpression) {
-            out.push(arg.text);
-        }
-        else if (arg instanceof IdentifierExpression) {
-            out.push(arg.text);
-        }
-    }
-    return out;
+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
+//# sourceMappingURL=index.js.map