First commits be like

sunpy/core/utils.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise(_ => setTimeout(_, ms));
+}

sunpy/core/vector.js

@@ -0,0 +1,116 @@
+const DIM_NAMES = ["xr", "yg", "zb", "wa"];
+const ARRAY_TYPES = [
+    Int8Array, Int16Array, Int32Array,
+    Uint8Array, Uint16Array, Uint32Array,
+    Float32Array, Float64Array,
+    BigInt64Array, BigUint64Array // Note: These requires values to be of type BigInt
+];
+
+export class Vector {
+    constructor(...values) {
+        this.type = Float32Array;
+
+        for (const value of values) {
+            if (ARRAY_TYPES.includes(value)) {
+                this.type = value;
+                break;
+            }
+        }
+
+        this.values = new this.type(values.filter(v => !ARRAY_TYPES.includes(v)));
+
+        const defineMacro = (index, key) => {
+            Object.defineProperty(this, key, {
+                get() { return this.values[index] },
+                set(value) { this.values[index] = value }
+            });
+        };
+
+        for (const i in this.values) {
+            defineMacro(i, i);
+
+            if (i >= DIM_NAMES.length)
+                continue;
+            
+            for (const names of DIM_NAMES[i]) {
+                for (const char of names) {
+                    defineMacro(i, char);
+                }
+            }
+        }
+    }
+
+    clone() {
+        return new Vector(this.type, ...this.values);
+    }
+
+    static _requireSameVector(vecA, vecB) {
+        if (!(vecA instanceof Vector))
+            throw new TypeError("vecA has to be instance of `Vector`");
+        
+        if (!(vecB instanceof Vector))
+            throw new TypeError("vecB has to be instance of `Vector`");
+
+        if (vecA.values.length !== vecB.values.length)
+            throw new TypeError("Vectors are of different lengths");
+        
+        if (vecA.type !== vecB.type)
+            console.warn("Vectors are not of same array type.. be careful!");
+    }
+
+    _modifyComponents(vec, func) {
+        if (vec instanceof Vector) {
+            Vector._requireSameVector(this, vec);
+            
+            for (const i in vec.values) {
+                this[i] = func(this[i], vec[i]);
+            }
+
+            return this;
+        }
+
+        for (const i in this.values) {
+            this[i] = func(this[i], vec); // vec is number here
+        }
+
+        return this;
+    }
+
+    // Basic operations
+    add = (vec) => this._modifyComponents(vec, (a, b) => a + b);
+    subtract = (vec) => this._modifyComponents(vec, (a, b) => a - b);
+    multiply = (vec) => this._modifyComponents(vec, (a, b) => a * b);
+    divide = (vec) => this._modifyComponents(vec, (a, b) => a / b);
+
+    // Basic algebra
+    length() {
+        return Math.sqrt( this.values.map(v => v * v).reduce((a, b) => a + b, 0) );
+    }
+
+    static normalize(vec) {
+        return vec.clone().divide(vec.length());
+    }
+
+    static distance(vecA, vecB) {
+        Vector._requireSameVector(vecA, vecB);
+        return Math.sqrt( vecA.values.map((v, i) => v - vecB[i]).map(v => v * v).reduce((a, b) => a + b, 0) );
+    }
+
+    static dot(vecA, vecB) {
+        Vector._requireSameVector(vecA, vecB);
+        return vecA.values.map((v, i) => v * vecB[i]).reduce((a, b) => a + b, 0);
+    }
+
+    static cross(vecA, vecB) {
+        Vector._requireSameVector(vecA, vecB);
+
+        if (vecA.values.length !== 3)
+            throw TypeError(`Vector3 required, got Vector${vecA.values.length}`);
+        
+        return new Vector(vecA.type,
+            vecA.y * vecB.z - vecA.z * vecB.y,
+            vecA.z * vecB.x - vecA.x * vecB.z,
+            vecA.x * vecB.y - vecA.y * vecB.x
+            );
+    }
+}