Add BigInt64Array shim for Safari 14

Author: hoodmane

src/preamble.js

@@ -295,8 +295,99 @@ function updateGlobalBufferAndViews(buf) {
   Module['HEAPF32'] = HEAPF32 = new Float32Array(buf);
   Module['HEAPF64'] = HEAPF64 = new Float64Array(buf);
 #if WASM_BIGINT
-  Module['HEAP64'] = HEAP64 = new BigInt64Array(buf);
-  Module['HEAPU64'] = HEAPU64 = new BigUint64Array(buf);
+  if(typeof BigInt64Array !== "undefined"){
+    Module['HEAP64'] = HEAP64 = new BigInt64Array(buf);
+    Module['HEAPU64'] = HEAPU64 = new BigUint64Array(buf);
+  } else {
+    function partsToBigIntSigned(lower, upper){
+      return BigInt(lower) | (BigInt(upper + 2 * (upper & 0x80000000)) << BigInt(32));
+    }
+
+    function partsToBigIntUnsigned(lower, upper){
+      return BigInt(lower) | (BigInt(upper) << BigInt(32));
+    }
+
+    function bigIntToParts(value){
+      var lower = Number((value) & BigInt(0xffffffff)) | 0;
+      var upper = (Number((value) >> BigInt(32)) | 0);
+      return [lower, upper];
+    }
+
+    function createBigIntArrayShim(partsToBigInt){
+      function createBigInt64Array(buf){
+        var array;
+        if(ArrayBuffer.isView(buf)){
+          array = buf;
+        } else {
+          array = new Uint32Array(buf);
+        }
+
+        let proxy = new Proxy({
+          slice : function(min, max){
+            var new_buf = array.slice(min * 2, max *2);
+            return createBigInt64Array(new_buf);
+          },
+          subarray : function(min, max){
+            var new_buf = array.subarray(min * 2, max *2);
+            return createBigInt64Array(new_buf);
+          },
+          [Symbol.iterator] : function*(){
+            for(var i = 0; i < (array.length)/2; i++){
+              yield partsToBigInt(array[2*i], array[2*i+1]);
+            }
+          },
+          buffer : array.buffer,
+          byteLength : array.byteLength,
+          offset : array.byteOffset / 2,
+          copyWithin : function(target, start, end){
+            array.copyWithin(target*2, start * 2, end*2);
+            return proxy;
+          },
+          set : function(source, targetOffset){
+            if(2*(source.length + targetOffset) > array.length){
+              // This is the Chrome error message
+              // Firefox: "invalid or out-of-range index"
+              throw new RangeError("offset is out of bounds"); 
+            }
+            for(var i = 0; i < array.length; i++){
+              var value = source[i];
+              var pair = bigIntToParts(BigInt(value));
+              array.set(pair, 2*(targetOffset + i));
+            }
+          }
+        }, {
+          get : function(target, idx, receiver){
+              if(!/^\d+$/.test(idx)){
+                return Reflect.get(target, idx, receiver);
+              }
+              var lower = array[idx * 2];
+              var upper = array[idx * 2 + 1];
+              return partsToBigInt(lower, upper);
+          },
+          set: function(target, idx, value, receiver) {
+            if(!/^\d+$/.test(idx)){
+              return Reflect.set(target, idx, value, receiver);
+            }
+            if(typeof value !== "bigint"){
+              // Chrome error message, Firefox has no "a".
+              throw new TypeError(`Cannot convert ${value} to a BigInt`);
+            }
+            var pair = bigIntToParts(value);
+            array.set(pair, 2*idx);
+          }
+        });
+        return proxy;
+      }
+      return createBigInt64Array;
+    }
+    
+    var createBigUint64Array = createBigIntArrayShim(partsToBigIntUnsigned);
+    var createBigInt64Array = createBigIntArrayShim(partsToBigIntSigned);
+
+    Module['HEAP64'] = HEAP64 = createBigInt64Array(HEAP);
+    Module['HEAPU64'] = HEAPU64 = createBigUint64Array(HEAP);
+  }
+
 #endif
 }