very strange things are happening?

Author: sliemeobn

Plugins/PackageToJS/Templates/runtime.mjs

@@ -49,13 +49,15 @@ const decode = (kind, payload1, payload2, objectSpace) => {
 // Note:
 // `decodeValues` assumes that the size of RawJSValue is 16.
 const decodeArray = (ptr, length, memory, objectSpace) => {
+    const basePtr = ptr >>> 0;
+    const count = length >>> 0;
     // fast path for empty array
-    if (length === 0) {
+    if (count === 0) {
         return [];
     }
     let result = [];
-    for (let index = 0; index < length; index++) {
-        const base = ptr + 16 * index;
+    for (let index = 0; index < count; index++) {
+        const base = basePtr + 16 * index;
         const kind = memory.getUint32(base, true);
         const payload1 = memory.getUint32(base + 4, true);
         const payload2 = memory.getFloat64(base + 8, true);
@@ -69,25 +71,27 @@ const decodeArray = (ptr, length, memory, objectSpace) => {
 // This function should be used only when kind flag is stored in memory.
 const write = (value, kind_ptr, payload1_ptr, payload2_ptr, is_exception, memory, objectSpace) => {
     const kind = writeAndReturnKindBits(value, payload1_ptr, payload2_ptr, is_exception, memory, objectSpace);
-    memory.setUint32(kind_ptr, kind, true);
+    memory.setUint32(kind_ptr >>> 0, kind, true);
 };
 const writeAndReturnKindBits = (value, payload1_ptr, payload2_ptr, is_exception, memory, objectSpace) => {
     const exceptionBit = (is_exception ? 1 : 0) << 31;
+    const payload1Offset = payload1_ptr >>> 0;
+    const payload2Offset = payload2_ptr >>> 0;
     if (value === null) {
         return exceptionBit | 4 /* Kind.Null */;
     }
     const writeRef = (kind) => {
-        memory.setUint32(payload1_ptr, objectSpace.retain(value), true);
+        memory.setUint32(payload1Offset, objectSpace.retain(value), true);
         return exceptionBit | kind;
     };
     const type = typeof value;
     switch (type) {
         case "boolean": {
-            memory.setUint32(payload1_ptr, value ? 1 : 0, true);
+            memory.setUint32(payload1Offset, value ? 1 : 0, true);
             return exceptionBit | 0 /* Kind.Boolean */;
         }
         case "number": {
-            memory.setFloat64(payload2_ptr, value, true);
+            memory.setFloat64(payload2Offset, value, true);
             return exceptionBit | 2 /* Kind.Number */;
         }
         case "string": {
@@ -114,9 +118,11 @@ const writeAndReturnKindBits = (value, payload1_ptr, payload2_ptr, is_exception,
     throw new Error("Unreachable");
 };
 function decodeObjectRefs(ptr, length, memory) {
-    const result = new Array(length);
-    for (let i = 0; i < length; i++) {
-        result[i] = memory.getUint32(ptr + 4 * i, true);
+    const basePtr = ptr >>> 0;
+    const count = length >>> 0;
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+        result[i] = memory.getUint32(basePtr + 4 * i, true);
     }
     return result;
 }
@@ -617,25 +623,29 @@ class SwiftRuntime {
                 const memory = this.memory;
                 const bytes = this.textEncoder.encode(memory.getObject(ref));
                 const bytes_ptr = memory.retain(bytes);
-                this.getDataView().setUint32(bytes_ptr_result, bytes_ptr, true);
+                this.getDataView().setUint32(bytes_ptr_result >>> 0, bytes_ptr, true);
                 return bytes.length;
             },
             swjs_decode_string: 
             // NOTE: TextDecoder can't decode typed arrays backed by SharedArrayBuffer
             this.options.sharedMemory == true
                 ? (bytes_ptr, length) => {
-                    const bytes = this.getUint8Array().slice(bytes_ptr, bytes_ptr + length);
+                    const bytesOffset = bytes_ptr >>> 0;
+                    const byteLength = length >>> 0;
+                    const bytes = this.getUint8Array().slice(bytesOffset, bytesOffset + byteLength);
                     const string = this.textDecoder.decode(bytes);
                     return this.memory.retain(string);
                 }
                 : (bytes_ptr, length) => {
-                    const bytes = this.getUint8Array().subarray(bytes_ptr, bytes_ptr + length);
+                    const bytesOffset = bytes_ptr >>> 0;
+                    const byteLength = length >>> 0;
+                    const bytes = this.getUint8Array().subarray(bytesOffset, bytesOffset + byteLength);
                     const string = this.textDecoder.decode(bytes);
                     return this.memory.retain(string);
                 },
             swjs_load_string: (ref, buffer) => {
                 const bytes = this.memory.getObject(ref);
-                this.getUint8Array().set(bytes, buffer);
+                this.getUint8Array().set(bytes, buffer >>> 0);
             },
             swjs_call_function: (ref, argv, argc, payload1_ptr, payload2_ptr) => {
                 const memory = this.memory;
@@ -739,7 +749,7 @@ class SwiftRuntime {
                     // See https://github.com/swiftwasm/swift/issues/5599
                     return this.memory.retain(new ArrayType());
                 }
-                const array = new ArrayType(this.wasmMemory.buffer, elementsPtr, length);
+                const array = new ArrayType(this.wasmMemory.buffer, elementsPtr >>> 0, length >>> 0);
                 // Call `.slice()` to copy the memory
                 return this.memory.retain(array.slice());
             },
@@ -750,7 +760,7 @@ class SwiftRuntime {
                 const memory = this.memory;
                 const typedArray = memory.getObject(ref);
                 const bytes = new Uint8Array(typedArray.buffer);
-                this.getUint8Array().set(bytes, buffer);
+                this.getUint8Array().set(bytes, buffer >>> 0);
             },
             swjs_release: (ref) => {
                 this.memory.release(ref);