json-as 1.0.4 → 1.0.5

package/assembly/index.ts

@@ -4,6 +4,7 @@ import { bs } from "../lib/as-bs";
 import { serializeString } from "./serialize/simple/string";
 import { serializeArray } from "./serialize/simple/array";
 import { serializeMap } from "./serialize/simple/map";
+import { serializeDate } from "./serialize/simple/date";
 import { deserializeBoolean } from "./deserialize/simple/bool";
 import { deserializeArray } from "./deserialize/simple/array";
 import { deserializeFloat } from "./deserialize/simple/float";
@@ -28,6 +29,8 @@ import { serializeObject } from "./serialize/simple/object";
 import { deserializeObject } from "./deserialize/simple/object";
 import { serializeRaw } from "./serialize/simple/raw";
 import { deserializeRaw } from "./deserialize/simple/raw";
+import { isSpace } from "util/string";
+import { deserializeString_SIMD } from "./deserialize/simd/string";
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -179,8 +182,14 @@ export namespace JSON {
       // @ts-ignore
       return null;
     } else if (isString<T>()) {
+      if (dataSize < 4) throw new Error("Cannot parse data as string because it was formatted incorrectly!");
+      // if (ASC_FEATURE_SIMD) {
+      // // @ts-ignore
+      //   return changetype<string>(deserializeString_SIMD(dataPtr, dataPtr + dataSize, __new(dataSize - 4, idof<string>())));
+      // } else {
       // @ts-ignore
       return deserializeString(dataPtr, dataPtr + dataSize, __new(dataSize - 4, idof<string>()));
+      // }
     } else if (isArray<T>()) {
       // @ts-ignore
       return inline.always(deserializeArray<nonnull<T>>(dataPtr, dataPtr + dataSize, changetype<usize>(instantiate<T>())));
@@ -210,6 +219,7 @@ export namespace JSON {
         // @ts-ignore: type
         return deserializeRaw(dataPtr, dataPtr + dataSize);
       } else if (type instanceof JSON.Value) {
+        // should cut out whitespace here
         // @ts-ignore
         return inline.always(deserializeArbitrary(dataPtr, dataPtr + dataSize, 0));
       } else if (type instanceof JSON.Obj) {
@@ -478,7 +488,6 @@ export namespace JSON {
       const out = changetype<JSON.Obj>(__new(offsetof<JSON.Obj>(), idof<JSON.Obj>()));
 
       if (value instanceof Map) {
-
       }
       return out;
     }
@@ -579,14 +588,15 @@ export namespace JSON {
     } else if (isFloat<T>()) {
       return deserializeFloat<T>(srcStart, srcEnd);
     } else if (isString<T>()) {
+      if (srcEnd - srcStart < 4) throw new Error("Cannot parse data as string because it was formatted incorrectly!");
       // @ts-ignore: type
       return deserializeString(srcStart, srcEnd, dst);
-    } else if (isArray<T>()) {
-      // @ts-ignore: type
-      return inline.always(deserializeArray<T>(srcStart, srcEnd, dst));
     } else if (isNullable<T>() && srcEnd - srcStart == 8 && load<u64>(srcStart) == 30399761348886638) {
       // @ts-ignore
       return null;
+    } else if (isArray<T>()) {
+      // @ts-ignore: type
+      return inline.always(deserializeArray<T>(srcStart, srcEnd, dst));
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
       // @ts-ignore: Defined by transform
@@ -630,9 +640,15 @@ export namespace JSON {
 }
 
 // @ts-ignore: inline
-@inline export function toRaw(data: string): JSON.Raw { return new JSON.Raw(data) }
+@inline export function toRaw(data: string): JSON.Raw {
+  return new JSON.Raw(data);
+}
 // @ts-ignore: inline
-@inline export function fromRaw(data: JSON.Raw): string { return data.data }
+@inline export function fromRaw(data: JSON.Raw): string {
+  return data.data;
+}
 
 // @ts-ignore: inline
-@inline export function toBox<T>(data: T): JSON.Box<T> { return new JSON.Box<T>(data) }
+@inline export function toBox<T>(data: T): JSON.Box<T> {
+  return new JSON.Box<T>(data);
+}

package/assembly/serialize/simd/string.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";

package/assembly/serialize/simple/integer.ts

@@ -10,4 +10,4 @@ import { itoa_buffered } from "util/number";
 }
 
 // 32 {"x":,"y":,"z"}
-// 18 3.41.28.3
+// 18 3.41.28.3

package/assembly/serialize/simple/object.ts

@@ -5,13 +5,14 @@ import { bytes } from "../../util";
 
 export function serializeObject(data: JSON.Obj): void {
   if (!data.size) {
-    store<u32>(bs.offset, 0);
+    bs.proposeSize(4);
+    store<u32>(bs.offset, 8192123);
     bs.offset += 4;
     return;
   }
 
-  // This grabs `JSON.Obj.stackSize` which is private
-  bs.ensureSize(load<u32>(changetype<usize>(data), offsetof<JSON.Obj>("stackSize")) - 2);
+
+  bs.proposeSize(load<u32>(changetype<usize>(data), offsetof<JSON.Obj>("stackSize")) - 2);
   const keys = data.keys();
   const values = data.values();
 
@@ -25,7 +26,7 @@ export function serializeObject(data: JSON.Obj): void {
   const keySize = bytes(firstKey);
   store<u16>(bs.offset, QUOTE);
   memory.copy(bs.offset + 2, changetype<usize>(firstKey), keySize);
-  store<u32>(bs.offset += keySize + 2, 3801122); // ":
+  store<u32>((bs.offset += keySize + 2), 3801122); // ":
   bs.offset += 4;
   JSON.__serialize(unchecked(values[0]));
 
@@ -34,11 +35,11 @@ export function serializeObject(data: JSON.Obj): void {
     const keySize = bytes(key);
     store<u32>(bs.offset, 2228268); // ,"
     memory.copy(bs.offset + 4, changetype<usize>(key), keySize);
-    store<u32>(bs.offset += keySize + 4, 3801122); // ":
+    store<u32>((bs.offset += keySize + 4), 3801122); // ":
     bs.offset += 4;
     JSON.__serialize(unchecked(values[i]));
   }
 
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
-}
+}

package/assembly/test.ts

@@ -5,9 +5,10 @@ import { bytes } from "./util";
 class Obj {
   public a: string = "hello";
   public b: string = "world";
-  public c: string = "\"\t\f\u0000\u0001";
+  public c: string = '"\t\f\u0000\u0001';
 }
 
+
 @json
 class Vec3 {
   x: f32 = 0.0;
@@ -15,8 +16,10 @@ class Vec3 {
   z: f32 = 0.0;
 }
 
+
 @json
 class Player {
+
   @alias("first name")
   firstName!: string;
   lastName!: string;
@@ -24,11 +27,13 @@ class Player {
   // Drop in a code block, function, or expression that evaluates to a boolean
   @omitif((self: Player) => self.age < 18)
   age!: i32;
+
   @omitnull()
   pos!: Vec3 | null;
   isVerified!: boolean;
 }
 
+
 @json
 class Point {
   x: f64 = 0.0;
@@ -37,10 +42,12 @@ class Point {
     this.x = x;
     this.y = y;
   }
+
   @serializer
   serializer(self: Point): string {
     return `(${self.x},${self.y})`;
   }
+
   @deserializer
   deserializer(data: string): Point | null {
     const dataSize = bytes(data);
@@ -50,18 +57,17 @@ class Point {
     const x = data.slice(1, c);
     const y = data.slice(c + 1, data.length - 1);
 
-    return new Point(
-      f64.parse(x),
-      f64.parse(y)
-    );
+    return new Point(f64.parse(x), f64.parse(y));
   }
 }
 
+
 @json
 class InnerObj<T> {
-  obj: T = instantiate<T>()
+  obj: T = instantiate<T>();
 }
 
+
 @json
 class ObjWithBracketString {
   data: string = "";
@@ -75,9 +81,9 @@ const player: Player = {
   pos: {
     x: 3.4,
     y: 1.2,
-    z: 8.3
+    z: 8.3,
   },
-  isVerified: true
+  isVerified: true,
 };
 
 const a1 = JSON.stringify("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u000f\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f");
@@ -98,7 +104,7 @@ const a4 = new JSON.Obj();
 a4.set("x", 1.5);
 a4.set("y", 5.4);
 a4.set("z", 9.8);
-a4.set("obj", obj)
+a4.set("obj", obj);
 a4.set<boolean>("bool", false);
 
 console.log("a4: " + JSON.stringify(a4));
@@ -115,37 +121,30 @@ const a7 = JSON.parse<JSON.Value[]>('["string",true,3.14,{"x":1.0,"y":2.0,"z":3.
 
 console.log("a7: " + JSON.stringify(a7));
 
-const a8 = JSON.stringify(["hello", JSON.stringify("world"),"working?"]);
+const a8 = JSON.stringify(["hello", JSON.stringify("world"), "working?"]);
 
 console.log("a8: " + a8);
 
-const a9 = JSON.stringify<JSON.Raw>(JSON.Raw.from("\"hello world\""));
+const a9 = JSON.stringify<JSON.Raw>(JSON.Raw.from('"hello world"'));
 
 console.log("a9: " + a9);
 
 const m10 = new Map<string, JSON.Raw>();
-m10.set("hello", new JSON.Raw("\"world\""));
-m10.set("pos", new JSON.Raw("{\"x\":1.0,\"y\":2.0,\"z\":3.0}"));
+m10.set("hello", new JSON.Raw('"world"'));
+m10.set("pos", new JSON.Raw('{"x":1.0,"y":2.0,"z":3.0}'));
 
 const a10 = JSON.stringify(m10);
 
 console.log("a10: " + a10);
 
-const a11 = JSON.parse<Vec3>('  {  "x"  :  3.4  ,  "y"   :   1.2    ,  "z"  :  8.3   }     ');
+const a11 = JSON.parse<JSON.Obj>('  {  "x"  :  3.4  ,  "y"   :   1.2    ,  "z"  :  8.3   }     ');
 
 console.log("a11: " + JSON.stringify(a11));
 
 const a12 = JSON.parse<InnerObj<ObjWithBracketString>>('{"obj":{"data":"hello} world"}}');
 
-console.log("a12: " + JSON.stringify(a12))
-
+console.log("a12: " + JSON.stringify(a12));
 
-@json
-class NullableObj {
-  bar: Bar | null = null;
-}
+const a13 = JSON.stringify<JSON.Obj>(new JSON.Obj());
 
-@json
-class Bar {
-  value: string = "";
-}
+console.log("a13: " + a13);

package/bench.js

@@ -34,9 +34,7 @@ const vec = {
 let data;
 
 const bench = new Bench({ time: 1000 })
-  .add("serialize vec3", () =>
-    data = JSON.stringify(vec)
-  )
+  .add("serialize vec3", () => (data = JSON.stringify(vec)))
   .add("deserialize vec3", () => {
     data = JSON.parse('{"x":3,"y":1,"z":8}');
   })
@@ -44,7 +42,7 @@ const bench = new Bench({ time: 1000 })
     data = JSON.stringify("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
   })
   .add("deserialize alphabet string", () => {
-    data = JSON.parse('"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\\\:;\\"\'?/>.<,\'\\"}"')
+    data = JSON.parse('"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\\\:;\\"\'?/>.<,\'\\"}"');
   }) /*
     .add("parse float", () => {
         data = JSON.parse("1.2345")

package/index.ts

@@ -1 +1 @@
-export { JSON } from "./assembly/index";
+export { JSON } from "./assembly/index";

package/lib/as-bs.ts

@@ -5,7 +5,7 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
  */
 export namespace bs {
   /** Current buffer pointer. */ // @ts-ignore
-  export let buffer: ArrayBuffer = new ArrayBuffer(32);//__new(32, idof<ArrayBuffer>());
+  export let buffer: ArrayBuffer = new ArrayBuffer(32); //__new(32, idof<ArrayBuffer>());
 
   /** Current offset within the buffer. */
   export let offset: usize = changetype<usize>(buffer);
@@ -28,10 +28,7 @@ export namespace bs {
       const deltaBytes = nextPowerOf2(size + 64);
       bufferSize += deltaBytes;
       // @ts-ignore: exists
-      const newPtr = changetype<ArrayBuffer>(__renew(
-        changetype<usize>(buffer),
-        bufferSize
-      ));
+      const newPtr = changetype<ArrayBuffer>(__renew(changetype<usize>(buffer), bufferSize));
       offset = offset + changetype<usize>(newPtr) - changetype<usize>(buffer);
       buffer = newPtr;
     }
@@ -49,10 +46,7 @@ export namespace bs {
       const deltaBytes = nextPowerOf2(size);
       bufferSize += deltaBytes;
       // @ts-ignore: exists
-      const newPtr = changetype<ArrayBuffer>(__renew(
-        changetype<usize>(buffer),
-        bufferSize
-      ));
+      const newPtr = changetype<ArrayBuffer>(__renew(changetype<usize>(buffer), bufferSize));
       offset = offset + changetype<usize>(newPtr) - changetype<usize>(buffer);
       buffer = newPtr;
     }
@@ -70,10 +64,7 @@ export namespace bs {
       const deltaBytes = nextPowerOf2(size + 64);
       bufferSize += deltaBytes;
       // @ts-ignore
-      const newPtr = changetype<ArrayBuffer>(__renew(
-        changetype<usize>(buffer),
-        bufferSize
-      ));
+      const newPtr = changetype<ArrayBuffer>(__renew(changetype<usize>(buffer), bufferSize));
       // if (buffer != newPtr) console.log("  Old: " + changetype<usize>(buffer).toString() + "\n  New: " + changetype<usize>(newPtr).toString());
       offset = offset + changetype<usize>(newPtr) - changetype<usize>(buffer);
       buffer = newPtr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "author": "Jairus Tanaka",
   "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "types": "assembly/index.ts",
@@ -44,7 +44,9 @@
     "lekiano",
     "Florian Guitton",
     "Matt Johnson-Pint",
-    "Tomáš Hromada"
+    "Tomáš Hromada",
+    "Loredana Cirstea",
+    "Accipiter Nisus"
   ],
   "keywords": [
     "assemblyscript",
@@ -65,4 +67,4 @@
     "@JairusSW:registry": "https://npm.pkg.github.com"
   },
   "type": "module"
-}
+}

package/run-tests.sh

@@ -7,7 +7,7 @@ for file in ./assembly/__tests__/*.spec.ts; do
   output="./build/${filename%.ts}.wasm"
 
   start_time=$(date +%s%3N)
-  npx asc "$file" --transform ./transform -o "$output" || { echo "Tests failed"; exit 1; }
+  npx asc "$file" --transform ./transform -o "$output" --enable simd || { echo "Tests failed"; exit 1; }
   end_time=$(date +%s%3N) 
 
   build_time=$((end_time - start_time))

package/transform/lib/index.js

@@ -1,19 +1,22 @@
 import { Node } from "assemblyscript/dist/assemblyscript.js";
 import { Transform } from "assemblyscript/dist/transform.js";
 import { Visitor } from "./visitor.js";
-import { SimpleParser, toString } from "./util.js";
+import { isStdlib, 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 {
+    program;
+    baseDir;
     parser;
     schemas = [];
     schema;
     sources = new Set();
     imports = [];
     topStatements = [];
+    simdStatements = [];
     visitClassDeclaration(node) {
         if (!node.decorators?.length)
             return;
@@ -29,8 +32,8 @@ class JSONTransform extends Visitor {
         if (process.env["JSON_DEBUG"])
             console.log("Created schema: " + this.schema.name + " in file " + node.range.source.normalizedPath);
         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"))];
+        const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer"))];
         if (serializers.length > 1)
             throwError("Multiple serializers detected for class " + node.name.text + " but schemas can only have one serializer!", serializers[1].range);
         if (deserializers.length > 1)
@@ -51,7 +54,7 @@ class JSONTransform extends Visitor {
             let SERIALIZER = "";
             SERIALIZER += "  __SERIALIZE_CUSTOM(ptr: usize): void {\n";
             SERIALIZER += "    const data = this." + serializer.name.text + "(changetype<" + this.schema.name + ">(ptr));\n";
-            SERIALIZER += "    if (isNullable(data) && changetype<usize>(data) == <usize>0) throw new Error(\"Could not serialize data using custom serializer!\");\n";
+            SERIALIZER += '    if (isNullable(data) && changetype<usize>(data) == <usize>0) throw new Error("Could not serialize data using custom serializer!");\n';
             SERIALIZER += "    const dataSize = data.length << 1;\n";
             SERIALIZER += "    memory.copy(bs.offset, changetype<usize>(data), dataSize);\n";
             SERIALIZER += "    bs.offset += dataSize;\n";
@@ -78,7 +81,7 @@ class JSONTransform extends Visitor {
             let DESERIALIZER = "";
             DESERIALIZER += "  __DESERIALIZE_CUSTOM(data: string): " + this.schema.name + " {\n";
             DESERIALIZER += "    const d = this." + deserializer.name.text + "(data)";
-            DESERIALIZER += "    if (isNullable(d) && changetype<usize>(d) == <usize>0) throw new Error(\"Could not deserialize data using custom deserializer!\");\n";
+            DESERIALIZER += '    if (isNullable(d) && changetype<usize>(d) == <usize>0) throw new Error("Could not deserialize data using custom deserializer!");\n';
             DESERIALIZER += "    return d;\n";
             DESERIALIZER += "  }\n";
             if (process.env["JSON_DEBUG"])
@@ -217,12 +220,13 @@ class JSONTransform extends Visitor {
             else if (member.type == "string" || member.type == "String") {
                 INITIALIZE += `  this.${member.name} = "";\n`;
             }
+            const SIMD_ENABLED = this.program.options.hasFeature(16);
             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)
+                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`;
@@ -232,7 +236,7 @@ class JSONTransform extends Visitor {
             else if (isRegular && !isPure) {
                 const keyPart = (isFirst ? "" : ",") + aliasName + ":";
                 this.schema.byteSize += keyPart.length << 1;
-                SERIALIZE += this.getStores(keyPart)
+                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`;
@@ -245,7 +249,7 @@ class JSONTransform extends Visitor {
                     indentInc();
                     const keyPart = aliasName + ":";
                     this.schema.byteSize += keyPart.length << 1;
-                    SERIALIZE += this.getStores(keyPart)
+                    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`;
@@ -269,7 +273,7 @@ class JSONTransform extends Visitor {
                         SERIALIZE += indent + `if (${toString(member.flags.get(PropertyFlags.OmitIf))}) {\n`;
                     }
                     indentInc();
-                    SERIALIZE += this.getStores(aliasName + ":")
+                    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`;
@@ -317,7 +321,9 @@ class JSONTransform extends Visitor {
             for (let i = 0; i < memberGroup.length; i++) {
                 const member = memberGroup[i];
                 const memberName = member.alias || member.name;
-                const dst = this.schemas.find(v => v.name == member.type) ? "ptr + offsetof<this>(\"" + member.name + "\") + 12" : "0";
+                const dst = this.schemas.find(v => v.name == member.type)
+                    ? "load<usize>(ptr + offsetof<this>(\"" + member.name + "\"))"
+                    : "0";
                 if (memberLen == 2) {
                     DESERIALIZE += `${indent}  case ${memberName.charCodeAt(0)}: { // ${memberName}\n`;
                     DESERIALIZE += `${indent}    store<${member.type}>(ptr, JSON.__deserialize<${member.type}>(valStart, valEnd, ${dst}), offsetof<this>(${JSON.stringify(member.name)}));\n`;
@@ -416,19 +422,17 @@ class JSONTransform extends Visitor {
     }
     addRequiredImports(node) {
         const filePath = fileURLToPath(import.meta.url);
-        const baseDir = path.resolve(filePath, '..', '..', '..');
-        const nodePath = path.resolve(process.cwd(), node.range.source.normalizedPath);
+        const baseDir = path.resolve(filePath, "..", "..", "..");
+        const nodePath = path.resolve(this.baseDir, node.range.source.normalizedPath);
         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"));
-        let bsPath = path.posix.join(...(path.relative(path.dirname(nodePath), path.join(baseDir, "lib", "as-bs")).split(path.sep))).replace(/^.*node_modules\/json-as/, "json-as");
-        let jsonPath = path.posix.join(...(path.relative(path.dirname(nodePath), path.join(baseDir, "assembly", "index.ts")).split(path.sep))).replace(/^.*node_modules\/json-as/, "json-as");
+        let bsPath = path.posix.join(...path.relative(path.dirname(nodePath), path.join(baseDir, "lib", "as-bs")).split(path.sep)).replace(/^.*node_modules\/json-as/, "json-as");
+        let jsonPath = path.posix.join(...path.relative(path.dirname(nodePath), path.join(baseDir, "assembly", "index.ts")).split(path.sep)).replace(/^.*node_modules\/json-as/, "json-as");
         if (!bsImport) {
             if (node.normalizedPath.startsWith("~")) {
                 bsPath = "json-as/lib/as-bs";
             }
-            const replaceNode = Node.createImportStatement([
-                Node.createImportDeclaration(Node.createIdentifierExpression("bs", node.range, false), null, node.range)
-            ], Node.createStringLiteralExpression(bsPath, node.range), node.range);
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("bs", node.range, false), null, node.range)], Node.createStringLiteralExpression(bsPath, node.range), node.range);
             this.topStatements.push(replaceNode);
             if (process.env["JSON_DEBUG"])
                 console.log("Added as-bs import: " + toString(replaceNode) + "\n");
@@ -437,9 +441,7 @@ class JSONTransform extends Visitor {
             if (node.normalizedPath.startsWith("~")) {
                 jsonPath = "json-as/assembly/index.ts";
             }
-            const replaceNode = Node.createImportStatement([
-                Node.createImportDeclaration(Node.createIdentifierExpression("JSON", node.range, false), null, node.range)
-            ], Node.createStringLiteralExpression(jsonPath, node.range), node.range);
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("JSON", node.range, false), null, node.range)], Node.createStringLiteralExpression(jsonPath, node.range), node.range);
             this.topStatements.push(replaceNode);
             if (process.env["JSON_DEBUG"])
                 console.log("Added json-as import: " + toString(replaceNode) + "\n");
@@ -450,6 +452,14 @@ class JSONTransform extends Visitor {
         const sizes = strToNum(data, simd);
         let offset = 0;
         for (const [size, num] of sizes) {
+            if (size == "v128" && simd) {
+                let index = this.simdStatements.findIndex((v) => v.includes(num));
+                let name = "SIMD_" + (index == -1 ? this.simdStatements.length : index);
+                if (index && !this.simdStatements.includes(`const ${name} = ${num};`))
+                    this.simdStatements.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;
@@ -467,36 +477,8 @@ class JSONTransform extends Visitor {
         return out;
     }
     isValidType(type, node) {
-        const validTypes = [
-            "string",
-            "u8",
-            "i8",
-            "u16",
-            "i16",
-            "u32",
-            "i32",
-            "u64",
-            "i64",
-            "f32",
-            "f64",
-            "bool",
-            "boolean",
-            "Date",
-            "JSON.Value",
-            "JSON.Obj",
-            "JSON.Raw",
-            "Value",
-            "Obj",
-            "Raw",
-            ...this.schemas.map((v) => v.name)
-        ];
-        const baseTypes = [
-            "Array",
-            "Map",
-            "Set",
-            "JSON.Box",
-            "Box"
-        ];
+        const validTypes = ["string", "u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "f32", "f64", "bool", "boolean", "Date", "JSON.Value", "JSON.Obj", "JSON.Raw", "Value", "Obj", "Raw", ...this.schemas.map((v) => v.name)];
+        const baseTypes = ["Array", "Map", "Set", "JSON.Box", "Box"];
         if (node && node.isGeneric && node.typeParameters)
             validTypes.push(...node.typeParameters.map((v) => v.name.text));
         if (type.endsWith("| null")) {
@@ -514,19 +496,35 @@ class JSONTransform extends Visitor {
 export default class Transformer extends Transform {
     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] !== "~") {
+        const sources = parser.sources
+            .filter((source) => {
+            const p = source.internalPath;
+            if (p.startsWith("~lib/rt") || p.startsWith("~lib/performance") || p.startsWith("~lib/wasi_") || p.startsWith("~lib/shared/")) {
+                return false;
+            }
+            return !isStdlib(source);
+        })
+            .sort((a, b) => {
+            if (a.sourceKind >= 2 && b.sourceKind <= 1) {
                 return -1;
             }
-            else if (a[0] !== "~" && b[0] == "~") {
+            else if (a.sourceKind <= 1 && b.sourceKind >= 2) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        })
+            .sort((a, b) => {
+            if (a.sourceKind === 1) {
                 return 1;
             }
             else {
                 return 0;
             }
         });
+        transformer.baseDir = path.join(process.cwd(), this.baseDir);
+        transformer.program = this.program;
         transformer.parser = parser;
         for (const source of sources) {
             transformer.imports = [];
@@ -536,6 +534,11 @@ export default class Transformer extends Transform {
                 source.statements.unshift(...transformer.topStatements);
                 transformer.topStatements = [];
             }
+            if (transformer.simdStatements.length) {
+                for (const simd of transformer.simdStatements)
+                    source.statements.unshift(SimpleParser.parseTopLevelStatement(simd));
+            }
+            transformer.simdStatements = [];
         }
         const schemas = transformer.schemas;
         for (const schema of schemas) {