json-as 1.2.5 → 1.3.0

package/transform/lib/index.js

@@ -13,6 +13,16 @@ const WRITE = process.env["JSON_WRITE"]?.trim();
 const rawValue = process.env["JSON_DEBUG"]?.trim();
 const DEBUG = rawValue === "true" ? 1 : rawValue === "false" || rawValue === "" ? 0 : isNaN(Number(rawValue)) ? 0 : Number(rawValue);
 const STRICT = process.env["JSON_STRICT"] && process.env["JSON_STRICT"] == "true";
+const USE_FAST_PATH = process.env["JSON_USE_FAST_PATH"]?.trim() === "1";
+function needsReferenceLoad(type) {
+    return type == "ArrayBuffer" || type == "Int8Array" || type == "Uint8Array" || type == "Uint8ClampedArray" || type == "Int16Array" || type == "Uint16Array" || type == "Int32Array" || type == "Uint32Array" || type == "Int64Array" || type == "Uint64Array" || type == "Float32Array" || type == "Float64Array";
+}
+function getSerializeCall(type, realName) {
+    if (type == "ArrayBuffer") {
+        return `JSON.__serializeArrayBuffer(load<ArrayBuffer>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+    }
+    return needsReferenceLoad(type) ? `JSON.__serialize<${type}>(changetype<${type}>(load<usize>(ptr, offsetof<this>(${JSON.stringify(realName)}))));\n` : `JSON.__serialize<${type}>(load<${type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+}
 export class JSONTransform extends Visitor {
     static SN = new JSONTransform();
     program;
@@ -79,8 +89,8 @@ export class JSONTransform extends Visitor {
         if (!this.schemas.has(source.internalPath))
             this.schemas.set(source.internalPath, []);
         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"))];
-        const serializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "serializer"))];
-        const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer"))];
+        const serializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "serializer") && !v.name.text.startsWith("__try"))];
+        const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer") && !v.name.text.startsWith("__try"))];
         const schema = new Schema();
         schema.node = node;
         schema.name = source.getQualifiedName(node);
@@ -229,9 +239,12 @@ export class JSONTransform extends Visitor {
         this.schemas.get(source.internalPath).push(schema);
         this.schema = schema;
         this.visitedClasses.add(fullClassPath);
+        const codegenMode = getCodegenMode(this.program);
+        const useFastPath = USE_FAST_PATH && codegenMode !== JSONMode.NAIVE;
         let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
         let INITIALIZE = "@inline __INITIALIZE(): this {\n";
-        let DESERIALIZE = "__DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
+        let DESERIALIZE = "__DESERIALIZE_SLOW<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
+        let DESERIALIZE_FAST = "@inline __DESERIALIZE_FAST<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
         let DESERIALIZE_CUSTOM = "";
         let SERIALIZE_CUSTOM = "";
         if (DEBUG > 0)
@@ -277,8 +290,10 @@ export class JSONTransform extends Visitor {
             if (!deserializer.decorators.some((v) => v.name.text == "inline")) {
                 deserializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", deserializer.range), null, deserializer.range));
             }
-            DESERIALIZE_CUSTOM += "  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
-            DESERIALIZE_CUSTOM += "    return inline.always(this." + deserializer.name.text + "(JSON.Util.ptrToStr(srcStart, srcEnd)));\n";
+            DESERIALIZE_CUSTOM += "  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
+            DESERIALIZE_CUSTOM += "    const data = inline.always(this." + deserializer.name.text + "(JSON.Util.ptrToStr(srcStart, srcEnd)));\n";
+            DESERIALIZE_CUSTOM += "    memory.copy(changetype<usize>(out), changetype<usize>(data), offsetof<nonnull<__JSON_T>>());\n";
+            DESERIALIZE_CUSTOM += "    return srcEnd;\n";
             DESERIALIZE_CUSTOM += "  }\n";
         }
         if (!members.length && !deserializers.length && !serializers.length) {
@@ -308,11 +323,7 @@ export class JSONTransform extends Visitor {
                     switch (decoratorName) {
                         case "alias": {
                             const arg = decorator.args[0];
-                            if (!arg ||
-                                arg.kind != 16 &&
-                                    arg.literalKind != 2 &&
-                                    arg.literalKind != 1 &&
-                                    arg.literalKind != 0)
+                            if (!arg || (arg.kind != 16 && arg.literalKind != 2 && arg.literalKind != 1 && arg.literalKind != 0))
                                 throwError("@alias must have an argument of type string or number", member.range);
                             mem.alias = arg.value.toString();
                             break;
@@ -360,34 +371,36 @@ export class JSONTransform extends Visitor {
             const aliasName = JSON.stringify(member.alias || member.name);
             const realName = member.name;
             const isLast = i == this.schema.members.length - 1;
-            if (member.value) {
-                if (member.value != "null" && member.value != "0" && member.value != "0.0" && member.value != "false") {
-                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), ${member.value}, offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                }
-            }
-            else if (member.generic) {
-                INITIALIZE += `  if (isManaged<nonnull<${member.type}>>() || isReference<nonnull<${member.type}>>()) {\n`;
-                INITIALIZE += `    store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                INITIALIZE += `    if (isDefined(this.${member.name}.__INITIALIZE)) changetype<nonnull<${member.type}>>(this.${member.name}).__INITIALIZE();\n`;
-                INITIALIZE += `  }\n`;
-            }
-            else if (!member.node.type.isNullable) {
-                if (this.getSchema(member.type)) {
-                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                }
-                else if (member.type.startsWith("Array<")) {
-                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), [], offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                }
-                else if (member.type.startsWith("Map<")) {
-                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                }
-                else if (member.type.startsWith("Set<")) {
-                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+            if (!useFastPath) {
+                if (member.value) {
+                    if (member.value != "null" && member.value != "0" && member.value != "0.0" && member.value != "false") {
+                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), ${member.value}, offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    }
                 }
-                else if (member.type.startsWith("StaticArray<")) {
+                else if (member.generic) {
+                    INITIALIZE += `  if (isManaged<nonnull<${member.type}>>() || isReference<nonnull<${member.type}>>()) {\n`;
+                    INITIALIZE += `    store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    INITIALIZE += `    if (isDefined(this.${member.name}.__INITIALIZE)) changetype<nonnull<${member.type}>>(this.${member.name}).__INITIALIZE();\n`;
+                    INITIALIZE += `  }\n`;
                 }
-                else if (member.type == "string" || member.type == "String") {
-                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), "", offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                else if (!member.node.type.isNullable) {
+                    if (this.getSchema(member.type)) {
+                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    }
+                    else if (member.type.startsWith("Array<")) {
+                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), [], offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    }
+                    else if (member.type.startsWith("Map<")) {
+                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    }
+                    else if (member.type.startsWith("Set<")) {
+                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    }
+                    else if (member.type.startsWith("StaticArray<")) {
+                    }
+                    else if (member.type == "string" || member.type == "String") {
+                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), "", offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                    }
                 }
             }
             const SIMD_ENABLED = this.program.options.hasFeature(16);
@@ -399,7 +412,7 @@ export class JSONTransform extends Visitor {
                 SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
                     .map((v) => indent + v + "\n")
                     .join("");
-                SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+                SERIALIZE += indent + getSerializeCall(member.type, realName);
                 if (isFirst)
                     isFirst = false;
             }
@@ -409,7 +422,7 @@ export class JSONTransform extends Visitor {
                 SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
                     .map((v) => indent + v + "\n")
                     .join("");
-                SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+                SERIALIZE += indent + getSerializeCall(member.type, realName);
                 if (isFirst)
                     isFirst = false;
             }
@@ -422,7 +435,7 @@ export class JSONTransform extends Visitor {
                     SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
                         .map((v) => indent + v + "\n")
                         .join("");
-                    SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+                    SERIALIZE += indent + getSerializeCall(member.type, realName);
                     if (!isLast) {
                         this.schema.byteSize += 2;
                         SERIALIZE += indent + `store<u16>(bs.offset, 44, 0); // ,\n`;
@@ -440,13 +453,15 @@ export class JSONTransform extends Visitor {
                         SERIALIZE += indent + `if (!(${toString(member.flags.get(PropertyFlags.OmitIf))})(this)) {\n`;
                     }
                     else {
-                        SERIALIZE += indent + `if (${toString(member.flags.get(PropertyFlags.OmitIf))}) {\n`;
+                        const expression = member.flags.get(PropertyFlags.OmitIf);
+                        const rendered = expression.kind == 16 && expression.literalKind == 2 ? JSON.stringify(expression.value).slice(1, -1) : toString(expression);
+                        SERIALIZE += indent + `if (!(${rendered})) {\n`;
                     }
                     indentInc();
                     SERIALIZE += this.getStores(aliasName + ":", SIMD_ENABLED)
                         .map((v) => indent + v + "\n")
                         .join("");
-                    SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+                    SERIALIZE += indent + getSerializeCall(member.type, realName);
                     if (!isLast) {
                         this.schema.byteSize += 2;
                         SERIALIZE += indent + `store<u16>(bs.offset, 44, 0); // ,\n`;
@@ -490,7 +505,246 @@ export class JSONTransform extends Visitor {
                     sortedMembers.object.push(member);
             }
         }
-        indent = "";
+        const getComparisions = (data, ptr, operator) => {
+            const dataBytes = data.length << 1;
+            let offset = 0;
+            const output = [];
+            while (offset < dataBytes) {
+                const rem = dataBytes - offset;
+                if (rem >= 8) {
+                    output.push(`load<u64>(${ptr}, ${offset}) ${operator} 0x${toU64(data, offset >> 1).toString(16)}`);
+                    offset += 8;
+                    continue;
+                }
+                if (rem >= 4) {
+                    output.push(`load<u32>(${ptr}, ${offset}) ${operator} 0x${toU32(data, offset >> 1).toString(16)}`);
+                    offset += 4;
+                    continue;
+                }
+                if (rem >= 2) {
+                    output.push(`load<u16>(${ptr}, ${offset}) ${operator} 0x${data.charCodeAt(offset >> 1).toString(16)}`);
+                    offset += 2;
+                    continue;
+                }
+            }
+            return output;
+        };
+        const UNSIGNED_INTEGER_TYPES = ["u8", "u16", "u32", "u64", "usize"];
+        const SIGNED_INTEGER_TYPES = ["i8", "i16", "i32", "i64", "isize"];
+        const FLOAT_TYPES = ["f32", "f64"];
+        const INTEGER_TYPES = [...UNSIGNED_INTEGER_TYPES, ...SIGNED_INTEGER_TYPES];
+        const STRING_FIELD_DESERIALIZER = codegenMode === JSONMode.SIMD ? "deserializeStringField_SIMD" : "deserializeStringField_SWAR";
+        const getArrayValueType = (type) => {
+            if (type.startsWith("Array<") || type.startsWith("StaticArray<")) {
+                return stripNull(type.slice(type.indexOf("<") + 1, -1).trim());
+            }
+            return null;
+        };
+        const getDeserializer = (type, srcPtr, outPtr, member, keyOffset = 0) => {
+            const out = [];
+            const resolvedType = stripNull(type);
+            const fieldOffset = `offsetof<this>(${JSON.stringify(member.name)})`;
+            const fieldPtr = `${outPtr} + offsetof<this>(${JSON.stringify(member.name)})`;
+            const valuePtr = keyOffset ? `${srcPtr} + ${keyOffset}` : srcPtr;
+            if (INTEGER_TYPES.includes(resolvedType)) {
+                const helper = SIGNED_INTEGER_TYPES.includes(resolvedType) ? "deserializeIntegerField" : "deserializeUnsignedField";
+                out.push(`${srcPtr} = ${helper}<${resolvedType}>(${valuePtr}, srcEnd, ${fieldPtr});`);
+            }
+            else if (["string", "String"].includes(resolvedType)) {
+                out.push("{");
+                if (member.node.type.isNullable) {
+                    out.push(`  if (load<u64>(${valuePtr}) == 30399761348886638) {`);
+                    out.push(`    store<${member.type}>(${outPtr}, changetype<${member.type}>(0), ${fieldOffset});`);
+                    out.push(`    ${srcPtr} = ${valuePtr} + 8;`);
+                    out.push("  } else {");
+                }
+                out.push(`  ${srcPtr} = ${STRING_FIELD_DESERIALIZER}<${member.type}>(${valuePtr}, srcEnd, ${fieldPtr});`);
+                if (member.node.type.isNullable) {
+                    out.push("  }");
+                }
+                out.push("}");
+            }
+            else if (isBoolean(resolvedType)) {
+                out.push("{");
+                out.push(`  if (load<u64>(${srcPtr}) == 28429475166421108) {`);
+                out.push(`    store<${resolvedType}>(${outPtr}, true, ${fieldOffset});`);
+                out.push(`    ${srcPtr} += 8;`);
+                out.push("  } else if (load<u64>(" + srcPtr + ") == 32370086184550502 && load<u16>(" + srcPtr + ", 8) == 101) {");
+                out.push(`    store<${resolvedType}>(${outPtr}, false, ${fieldOffset});`);
+                out.push(`    ${srcPtr} += 10;`);
+                out.push("  } else break;");
+                out.push("}");
+            }
+            else if (FLOAT_TYPES.includes(resolvedType)) {
+                out.push(`${srcPtr} = deserializeFloatField<${resolvedType}>(${valuePtr}, srcEnd, ${fieldPtr});`);
+            }
+            else if (this.getSchema(resolvedType)) {
+                out.push("{");
+                if (member.node.type.isNullable) {
+                    out.push(`  if (load<u64>(${srcPtr}) == 30399761348886638) {`);
+                    out.push(`    store<${resolvedType}>(${outPtr}, changetype<${resolvedType}>(0), ${fieldOffset});`);
+                    out.push(`    ${srcPtr} += 8;`);
+                    out.push("  } else {");
+                }
+                out.push(`  let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
+                out.push("  if (changetype<usize>(value) == 0) {");
+                out.push(`    value = changetype<${resolvedType}>(__new(offsetof<nonnull<${resolvedType}>>(), idof<nonnull<${resolvedType}>>()));`);
+                out.push(`    store<${resolvedType}>(${outPtr}, value, ${fieldOffset});`);
+                out.push("  }");
+                out.push(`  ${srcPtr} = changetype<nonnull<${resolvedType}>>(value).__DESERIALIZE<${resolvedType}>(${srcPtr}, srcEnd, value);`);
+                if (member.node.type.isNullable) {
+                    out.push("  }");
+                }
+                out.push("}");
+            }
+            else if (resolvedType.startsWith("Array<")) {
+                const valueType = getArrayValueType(resolvedType);
+                if (valueType && ["string", "String"].includes(valueType)) {
+                    out.push("{");
+                    out.push(`  if (load<u16>(${srcPtr}) != 0x5b) break;`);
+                    out.push(`  let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
+                    out.push("  if (changetype<usize>(value) == 0) {");
+                    out.push(`    value = [];`);
+                    out.push(`    store<${resolvedType}>(${outPtr}, value, ${fieldOffset});`);
+                    out.push("  }");
+                    out.push("  let index = 0;");
+                    out.push(`  ${srcPtr} += 2;`);
+                    out.push(`  if (load<u16>(${srcPtr}) == 0x5d) {`);
+                    out.push("    value.length = 0;");
+                    out.push(`    ${srcPtr} += 2;`);
+                    out.push("  } else while (true) {");
+                    out.push('    if (index >= value.length) value.push("");');
+                    out.push(`    ${srcPtr} = ${STRING_FIELD_DESERIALIZER}<${valueType}>(${srcPtr}, srcEnd, value.dataStart + ((<usize>index) << alignof<${valueType}>()));`);
+                    out.push("    index++;");
+                    out.push(`    const code = load<u16>(${srcPtr});`);
+                    out.push("    if (code == 0x2c) {");
+                    out.push(`      ${srcPtr} += 2;`);
+                    out.push("      continue;");
+                    out.push("    }");
+                    out.push("    if (code == 0x5d) {");
+                    out.push("      value.length = index;");
+                    out.push(`      ${srcPtr} += 2;`);
+                    out.push("      break;");
+                    out.push("    }");
+                    out.push("    break;");
+                    out.push("  }");
+                    out.push("}");
+                }
+                else if (valueType && this.getSchema(valueType)) {
+                    out.push("{");
+                    out.push(`  if (load<u16>(${srcPtr}) != 0x5b) break;`);
+                    out.push(`  let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
+                    out.push("  if (changetype<usize>(value) == 0) {");
+                    out.push(`    value = [];`);
+                    out.push(`    store<${resolvedType}>(${outPtr}, value, ${fieldOffset});`);
+                    out.push("  }");
+                    out.push("  let index = 0;");
+                    out.push(`  ${srcPtr} += 2;`);
+                    out.push(`  if (load<u16>(${srcPtr}) == 0x5d) {`);
+                    out.push("    value.length = 0;");
+                    out.push(`    ${srcPtr} += 2;`);
+                    out.push("  } else while (true) {");
+                    out.push(`    let item: ${valueType};`);
+                    out.push("    if (index < value.length) {");
+                    out.push("      item = unchecked(value[index]);");
+                    out.push("      if (changetype<usize>(item) == 0) {");
+                    out.push(`        item = changetype<${valueType}>(__new(offsetof<nonnull<${valueType}>>(), idof<nonnull<${valueType}>>()));`);
+                    out.push("        unchecked((value[index] = item));");
+                    out.push("      }");
+                    out.push("    } else {");
+                    out.push(`      item = changetype<${valueType}>(__new(offsetof<nonnull<${valueType}>>(), idof<nonnull<${valueType}>>()));`);
+                    out.push("      value.push(item);");
+                    out.push("    }");
+                    out.push(`    ${srcPtr} = changetype<nonnull<${valueType}>>(item).__DESERIALIZE<${valueType}>(${srcPtr}, srcEnd, item);`);
+                    out.push("    index++;");
+                    out.push(`    const code = load<u16>(${srcPtr});`);
+                    out.push("    if (code == 0x2c) {");
+                    out.push(`      ${srcPtr} += 2;`);
+                    out.push("      continue;");
+                    out.push("    }");
+                    out.push("    if (code == 0x5d) {");
+                    out.push("      value.length = index;");
+                    out.push(`      ${srcPtr} += 2;`);
+                    out.push("      break;");
+                    out.push("    }");
+                    out.push("    break;");
+                    out.push("  }");
+                    out.push("}");
+                }
+                else {
+                    out.push(`${srcPtr} = deserializeArrayField_SWAR<${resolvedType}>(${srcPtr}, srcEnd, ${fieldPtr});`);
+                    out.push(`if (!${srcPtr}) break;`);
+                }
+            }
+            else {
+                out.push("{");
+                out.push(`  const valueStart = ${srcPtr};`);
+                out.push("  let depth: i32 = 0;");
+                out.push("  let inString = false;");
+                out.push(`  while (${srcPtr} < srcEnd) {`);
+                out.push(`    const code = load<u16>(${srcPtr});`);
+                out.push("    if (inString) {");
+                out.push(`      if (code == 0x22 && load<u16>(${srcPtr} - 2) != 0x5c) inString = false;`);
+                out.push(`      ${srcPtr} += 2;`);
+                out.push("      continue;");
+                out.push("    }");
+                out.push("    if (code == 0x22) {");
+                out.push("      inString = true;");
+                out.push(`      ${srcPtr} += 2;`);
+                out.push("      continue;");
+                out.push("    }");
+                out.push("    if (code == 0x7b || code == 0x5b) {");
+                out.push("      depth++;");
+                out.push(`      ${srcPtr} += 2;`);
+                out.push("      continue;");
+                out.push("    }");
+                out.push("    if (code == 0x7d || code == 0x5d) {");
+                out.push("      if (depth == 0) break;");
+                out.push("      depth--;");
+                out.push(`      ${srcPtr} += 2;`);
+                out.push("      continue;");
+                out.push("    }");
+                out.push("    if (code == 0x2c && depth == 0) break;");
+                out.push(`    ${srcPtr} += 2;`);
+                out.push("  }");
+                out.push(`  if (inString || depth != 0 || ${srcPtr} <= valueStart) break;`);
+                out.push(`  store<${resolvedType}>(${outPtr}, JSON.__deserialize<${resolvedType}>(valueStart, ${srcPtr}), ${fieldOffset});`);
+                out.push("}");
+            }
+            return out;
+        };
+        indent = "  ";
+        DESERIALIZE_FAST += indent + "const dst = changetype<usize>(out);\n";
+        DESERIALIZE_FAST += indent + "do {\n";
+        indent += "  ";
+        for (let i = 0; i < this.schema.members.length; i++) {
+            const member = this.schema.members[i];
+            const key = JSON.stringify(member.alias || member.name);
+            if (key.length <= 2)
+                throw new Error("Key cannot be empty!");
+            const keySection = (i == 0 ? "{" : ",") + key + ":";
+            DESERIALIZE_FAST += indent + `if ( // ${keySection}\n${(indent += "  ")}${getComparisions(keySection, "srcStart", "!=").join("\n" + indent + "|| ")}\n${(indent = indent.slice(0, -2))}) break;\n`;
+            const keyOffset = keySection.length << 1;
+            const resolvedType = stripNull(member.type);
+            const inlineStringValue = ["string", "String"].includes(resolvedType);
+            if (!inlineStringValue) {
+                DESERIALIZE_FAST += indent + `srcStart += ${keyOffset};\n\n`;
+            }
+            const deserializer = getDeserializer(member.type, "srcStart", "dst", member, inlineStringValue ? keyOffset : 0);
+            if (!deserializer.length) {
+                DESERIALIZE_FAST += indent + "break;\n\n";
+                continue;
+            }
+            DESERIALIZE_FAST += indent + deserializer.join("\n" + indent) + "\n\n";
+        }
+        DESERIALIZE_FAST += indent + "if (load<u16>(srcStart) !== 0x7d) break; // }\n";
+        DESERIALIZE_FAST += indent + "srcStart += 2;\n";
+        DESERIALIZE_FAST += indent + "return srcStart;\n";
+        indent = indent.slice(0, -2);
+        DESERIALIZE_FAST += indent + "} while (false);\n\n";
+        DESERIALIZE_FAST += indent + 'throw new Error("Failed to parse JSON ");';
+        indent = indent.slice(0, -2);
+        DESERIALIZE_FAST += indent + "}";
         DESERIALIZE += indent + "  let keyStart: usize = 0;\n";
         DESERIALIZE += indent + "  let keyEnd: usize = 0;\n";
         DESERIALIZE += indent + "  let isKey = false;\n";
@@ -856,7 +1110,7 @@ export class JSONTransform extends Visitor {
             DESERIALIZE += "\n      }";
             mbElse = " else ";
             DESERIALIZE += mbElse + "if (code == 102) {\n";
-            DESERIALIZE += "        if (load<u64>(srcStart, 2) == 28429466576093281) {\n";
+            DESERIALIZE += "        {\n";
             DESERIALIZE += "          srcStart += 10;\n";
             if (DEBUG > 1)
                 DESERIALIZE += '              console.log("Value (bool, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart - 10));';
@@ -894,9 +1148,6 @@ export class JSONTransform extends Visitor {
                 }
             }, "boolean");
             DESERIALIZE += "        }";
-            DESERIALIZE += " else {\n";
-            DESERIALIZE += "          throw new Error(\"Expected to find 'false' but found '\" + JSON.Util.ptrToStr(lastIndex, srcStart) + \"' instead at position \" + (srcEnd - srcStart).toString());\n";
-            DESERIALIZE += "        }";
             DESERIALIZE += "\n      }";
             mbElse = " else ";
         }
@@ -951,29 +1202,36 @@ export class JSONTransform extends Visitor {
         indentDec();
         DESERIALIZE += `  }\n`;
         indentDec();
-        DESERIALIZE += `  return out;\n}\n`;
+        DESERIALIZE += `  return srcStart;\n}\n`;
         indent = "  ";
         this.schema.byteSize += 2;
         SERIALIZE += indent + "store<u16>(bs.offset, 125, 0); // }\n";
         SERIALIZE += indent + "bs.offset += 2;\n";
         SERIALIZE += "}";
         SERIALIZE = SERIALIZE.slice(0, 32) + indent + "bs.proposeSize(" + this.schema.byteSize + ");\n" + SERIALIZE.slice(32);
-        INITIALIZE += "  return this;\n";
-        INITIALIZE += "}";
+        if (!useFastPath) {
+            INITIALIZE += "  return this;\n";
+            INITIALIZE += "}";
+        }
         if (DEBUG > 0) {
             console.log(SERIALIZE_CUSTOM || SERIALIZE);
-            console.log(INITIALIZE);
+            if (!useFastPath)
+                console.log(INITIALIZE);
             console.log(DESERIALIZE_CUSTOM || DESERIALIZE);
         }
+        const DESERIALIZE_DIRECT = useFastPath ? DESERIALIZE_FAST.replace("@inline __DESERIALIZE_FAST<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {", "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {") : DESERIALIZE.replace("__DESERIALIZE_SLOW<__JSON_T>", "__DESERIALIZE<__JSON_T>");
         const SERIALIZE_METHOD = SimpleParser.parseClassMember(SERIALIZE_CUSTOM || SERIALIZE, node);
-        const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
-        const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE_CUSTOM || DESERIALIZE, node);
+        const INITIALIZE_METHOD = !useFastPath ? SimpleParser.parseClassMember(INITIALIZE, node) : null;
+        const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE_CUSTOM || DESERIALIZE_DIRECT, node);
+        const DESERIALIZE_FAST_METHOD = useFastPath ? SimpleParser.parseClassMember(DESERIALIZE_FAST, node) : null;
         if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
             node.members.push(SERIALIZE_METHOD);
-        if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
+        if (!useFastPath && INITIALIZE_METHOD && !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 (!DESERIALIZE_CUSTOM && useFastPath && DESERIALIZE_FAST_METHOD && !node.members.find((v) => v.name.text == "__DESERIALIZE_FAST"))
+            node.members.push(DESERIALIZE_FAST_METHOD);
         super.visitClassDeclaration(node);
     }
     getSchema(name) {
@@ -983,18 +1241,20 @@ export class JSONTransform extends Visitor {
     generateEmptyMethods(node) {
         const SERIALIZE_EMPTY = "@inline __SERIALIZE(ptr: usize): void {\n  bs.proposeSize(4);\n  store<u32>(bs.offset, 8192123);\n  bs.offset += 4;\n}";
         const INITIALIZE_EMPTY = "@inline __INITIALIZE(): this {\n  return this;\n}";
-        const DESERIALIZE_EMPTY = "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n  return out;\n}";
+        const DESERIALIZE_EMPTY = "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n  return srcEnd;\n}";
+        const useFastPath = USE_FAST_PATH && getCodegenMode(this.program) !== JSONMode.NAIVE;
         if (DEBUG > 0) {
             console.log(SERIALIZE_EMPTY);
-            console.log(INITIALIZE_EMPTY);
+            if (!useFastPath)
+                console.log(INITIALIZE_EMPTY);
             console.log(DESERIALIZE_EMPTY);
         }
         const SERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_EMPTY, node);
-        const INITIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(INITIALIZE_EMPTY, node);
+        const INITIALIZE_METHOD_EMPTY = !useFastPath ? SimpleParser.parseClassMember(INITIALIZE_EMPTY, node) : null;
         const DESERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(DESERIALIZE_EMPTY, node);
         if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
             node.members.push(SERIALIZE_METHOD_EMPTY);
-        if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
+        if (!useFastPath && INITIALIZE_METHOD_EMPTY && !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);
@@ -1023,6 +1283,20 @@ export class JSONTransform extends Visitor {
         fromPath = fromPath.startsWith("~lib") ? fromPath.slice(5) : path.join(this.baseCWD, fromPath);
         const bsImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "bs" || d.name.text == "bs"));
         const jsonImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "JSON" || d.name.text == "JSON"));
+        const atoiImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "atoi" || d.name.text == "atoi"));
+        const deserializeIntegerFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeIntegerField" || d.name.text == "deserializeIntegerField"));
+        const deserializeUnsignedFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeUnsignedField" || d.name.text == "deserializeUnsignedField"));
+        const deserializeFloatFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeFloatField" || d.name.text == "deserializeFloatField"));
+        const deserializeArrayField_SWARImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeArrayField_SWAR" || d.name.text == "deserializeArrayField_SWAR"));
+        const deserializeStringFieldSWARImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeStringField_SWAR" || d.name.text == "deserializeStringField_SWAR"));
+        const deserializeStringFieldSIMDImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeStringField_SIMD" || d.name.text == "deserializeStringField_SIMD"));
+        const sourceText = readFileSync(fromPath).toString();
+        const hasLocalDeserializeIntegerField = /\bdeserializeIntegerField\b/.test(sourceText);
+        const hasLocalDeserializeUnsignedField = /\bdeserializeUnsignedField\b/.test(sourceText);
+        const hasLocalDeserializeFloatField = /\bdeserializeFloatField\b/.test(sourceText);
+        const hasLocaldeserializeArrayField_SWAR = /\bdeserializeArrayField_SWAR\b/.test(sourceText);
+        const hasLocalDeserializeStringFieldSWAR = /\bdeserializeStringField_SWAR\b/.test(sourceText);
+        const hasLocalDeserializeStringFieldSIMD = /\bdeserializeStringField_SIMD\b/.test(sourceText);
         let baseRel = path.posix.join(...path.relative(path.dirname(fromPath), path.join(baseDir)).split(path.sep));
         if (baseRel.endsWith("json-as")) {
             baseRel = "json-as" + baseRel.slice(baseRel.indexOf("json-as") + 7);
@@ -1042,6 +1316,49 @@ export class JSONTransform extends Visitor {
             if (DEBUG > 0)
                 console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
         }
+        if (!atoiImport) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("atoi", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "util", "atoi"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeIntegerFieldImport && !hasLocalDeserializeIntegerField) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeIntegerField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "integer"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeUnsignedFieldImport && !hasLocalDeserializeUnsignedField) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeUnsignedField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "unsigned"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeFloatFieldImport && !hasLocalDeserializeFloatField) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeFloatField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "float"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeArrayField_SWARImport && !hasLocaldeserializeArrayField_SWAR) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeArrayField_SWAR", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "array"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        const codegenMode = getCodegenMode(this.program);
+        if (codegenMode !== JSONMode.SIMD && !deserializeStringFieldSWARImport && !hasLocalDeserializeStringFieldSWAR) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeStringField_SWAR", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "swar", "string"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (codegenMode === JSONMode.SIMD && !deserializeStringFieldSIMDImport && !hasLocalDeserializeStringFieldSIMD) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeStringField_SIMD", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simd", "string"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
     }
     getStores(data, simd = false) {
         const out = [];
@@ -1051,7 +1368,7 @@ export class JSONTransform extends Visitor {
             if (size == "v128" && simd) {
                 const index = this.simdStatements.findIndex((v) => v.includes(num));
                 const name = "SIMD_" + (index == -1 ? this.simdStatements.length : index);
-                if (index && !this.simdStatements.includes(`const ${name} = ${num};`))
+                if (index == -1)
                     this.simdStatements.push(`const ${name} = ${num};`);
                 out.push("store<v128>(bs.offset, " + name + ", " + offset + "); // " + data.slice(offset >> 1, (offset >> 1) + 8));
                 offset += 16;
@@ -1096,6 +1413,23 @@ var JSONMode;
     JSONMode[JSONMode["NAIVE"] = 2] = "NAIVE";
 })(JSONMode || (JSONMode = {}));
 let MODE = JSONMode.SWAR;
+function getCodegenMode(program) {
+    let mode = program.options.hasFeature(16) ? JSONMode.SIMD : JSONMode.SWAR;
+    if (process.env["JSON_MODE"]) {
+        switch (process.env["JSON_MODE"].toLowerCase().trim()) {
+            case "simd":
+                mode = JSONMode.SIMD;
+                break;
+            case "swar":
+                mode = JSONMode.SWAR;
+                break;
+            case "naive":
+                mode = JSONMode.NAIVE;
+                break;
+        }
+    }
+    return mode;
+}
 export default class Transformer extends Transform {
     afterInitialize(program) {
         if (program.options.hasFeature(16))
@@ -1117,8 +1451,7 @@ export default class Transformer extends Transform {
             }
         }
         program.registerConstantInteger("JSON_MODE", Type.i32, i64_new(MODE));
-        if (process.env["JSON_CACHE"]?.trim().toLowerCase() === "true" ||
-            process.env["JSON_CACHE"]?.trim().toLowerCase() === "1") {
+        if (process.env["JSON_CACHE"]?.trim().toLowerCase() === "true" || process.env["JSON_CACHE"]?.trim().toLowerCase() === "1") {
             program.registerConstantInteger("JSON_CACHE", Type.bool, i64_one);
         }
     }
@@ -1192,16 +1525,16 @@ function sortMembers(members) {
     });
 }
 function toU16(data, offset = 0) {
-    return data.charCodeAt(offset + 0).toString();
+    return data.charCodeAt(offset + 0);
 }
 function toU32(data, offset = 0) {
-    return ((data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset + 0)).toString();
+    return (data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset + 0);
 }
 function toU48(data, offset = 0) {
-    return ((BigInt(data.charCodeAt(offset + 2)) << 32n) | (BigInt(data.charCodeAt(offset + 1)) << 16n) | BigInt(data.charCodeAt(offset + 0))).toString();
+    return (BigInt(data.charCodeAt(offset + 2)) << 32n) | (BigInt(data.charCodeAt(offset + 1)) << 16n) | BigInt(data.charCodeAt(offset + 0));
 }
 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();
+    return (BigInt(data.charCodeAt(offset + 3)) << 48n) | (BigInt(data.charCodeAt(offset + 2)) << 32n) | (BigInt(data.charCodeAt(offset + 1)) << 16n) | BigInt(data.charCodeAt(offset + 0));
 }
 function toMemCDecl(n, indent) {
     let out = "";