allotaxonometer-ui 0.1.13 → 0.1.15

package/dist/allotaxonometer_wasm-Kv_ZqZ1J.js

@@ -0,0 +1,371 @@
+let wasm;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * Main function exported to JavaScript
+ * Takes two systems with ranks and counts, returns divergence elements and normalization
+ * @param {Float64Array} ranks1
+ * @param {Float64Array} ranks2
+ * @param {Float64Array} counts1
+ * @param {Float64Array} counts2
+ * @param {number} alpha
+ * @returns {any}
+ */
+function rank_turbulence_divergence(ranks1, ranks2, counts1, counts2, alpha) {
+    const ptr0 = passArrayF64ToWasm0(ranks1, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(ranks2, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(counts1, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArrayF64ToWasm0(counts2, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.rank_turbulence_divergence(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, alpha);
+    return ret;
+}
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_Error_e17e777aac105295 = function(arg0, arg1) {
+        const ret = Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_new_2ff1f68f3676ea53 = function() {
+        const ret = new Map();
+        return ret;
+    };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+        arg0[arg1] = arg2;
+    };
+    imports.wbg.__wbg_set_90f6c0f7bd8c0415 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_set_b7f1cf4fae26fe2a = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
+        const ret = debugString(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+        // Cast intrinsic for `U64 -> Externref`.
+        const ret = BigInt.asUintN(64, arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+        // Cast intrinsic for `I64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+        // Cast intrinsic for `F64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_2;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+    };
+
+    return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module);
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path);
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead');
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL("data:application/wasm;base64,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", import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { __wbg_init as default, initSync, rank_turbulence_divergence };

package/dist/index.js

@@ -1525,10 +1525,20 @@ function tiedrank(arr) {
 
 function rank_maxlog10(mixedelements) {
   // Get maximum of log10 ranks from both systems, then round up
-  let logged_max = [
-    Math.max(...mixedelements[[0]].ranks), Math.max(...mixedelements[[1]].ranks)
-  ].map(Math.log10);
-  return Math.ceil(Math.max(...[logged_max[0], logged_max[1]]))
+  // Use loop to avoid stack overflow with large arrays (Math.max(...array) fails for 100K+ items)
+  let max1 = mixedelements[[0]].ranks[0];
+  for (let i = 1; i < mixedelements[[0]].ranks.length; i++) {
+    if (mixedelements[[0]].ranks[i] > max1) max1 = mixedelements[[0]].ranks[i];
+  }
+
+  let max2 = mixedelements[[1]].ranks[0];
+  for (let i = 1; i < mixedelements[[1]].ranks.length; i++) {
+    if (mixedelements[[1]].ranks[i] > max2) max2 = mixedelements[[1]].ranks[i];
+  }
+
+  const logged_max1 = Math.log10(max1);
+  const logged_max2 = Math.log10(max2);
+  return Math.ceil(Math.max(logged_max1, logged_max2))
 }
 
 function rin(arr1, arr2) {
@@ -1661,14 +1671,26 @@ function wordShift_dat(me, dat) {
   return out.slice().sort((a, b) => descending(Math.abs(a.metric), Math.abs(b.metric)))
 }
 
-// This function calculates the divergence between two arrays of inverse ranks
-// based on the specified alpha value. If alpha is equal to infinity, it returns
-// an array with the maximum of each element in inv_r1 and inv_r2. If alpha is
-// equal to 0, it returns an array with the log of the ratio of the maximum and
-// minimum of 1/inv_r1 and 1/inv_r2 for each element. Otherwise, it returns an
-// array with the absolute value of (alpha + 1)/alpha * (inv_r1^alpha - inv_r2^alpha)^(1/(alpha + 1))
-// for each element.
+// WASM module cache
+let wasmModule = null;
+let wasmInitialized = false;
+
+// Eagerly try to load WASM (but don't block)
+(async function initWASM() {
+  try {
+    const module = await import('./allotaxonometer_wasm-Kv_ZqZ1J.js');
+    await module.default(); // Initialize WASM
+    wasmModule = module;
+    wasmInitialized = true;
+    console.log('✅ WASM module loaded successfully');
+  } catch (e) {
+    console.warn('⚠️  WASM not available, using JS fallback:', e.message);
+    wasmModule = null;
+    wasmInitialized = false;
+  }
+})();
 
+// JavaScript fallback implementation
 function divElems(inv_r1, inv_r2, alpha) {
   if (alpha === Infinity) {
       return inv_r1.map((d,i) => inv_r1[i] == inv_r2[i] ? 0 : Math.max(inv_r1[i], inv_r2[i]))
@@ -1681,20 +1703,8 @@ function divElems(inv_r1, inv_r2, alpha) {
     }
 }
 
-// This function calculates the normalization factor for the divergence between
-// two arrays of inverse ranks. It first extracts the counts from the mixedelements
-// parameter and finds the indices where the counts are greater than 0. It then
-// calculates the disjoint set for each array based on the number of non-zero
-// counts. If alpha is equal to infinity, it returns the sum of the elements in
-// inv_r1 and inv_r2 for the indices with non-zero counts. If alpha is equal to
-// 0, it returns the sum of the absolute value of the log of the ratio of each
-// element in inv_r1 and the disjoint set for inv_r2, and the absolute value of
-// the log of the ratio of each element in inv_r2 and the disjoint set for inv_r1.
-// Otherwise, it returns the sum of (alpha + 1)/alpha * (inv_r1^alpha - disjoint set^alpha)^(1/(alpha + 1))
-// for each element in inv_r1, and the same for inv_r2.
-
 function norm_divElems(mixedelements, inv_r1, inv_r2, alpha) {
-  const c1 = mixedelements[0]['counts'];  
+  const c1 = mixedelements[0]['counts'];
   const c2 = mixedelements[1]['counts'];
 
   const indices1 = which(c1.map(d => d > 0));
@@ -1703,22 +1713,15 @@ function norm_divElems(mixedelements, inv_r1, inv_r2, alpha) {
   const N1 = indices1.length;
   const N2 = indices2.length;
 
-// This function calculates the disjoint set for a given array of inverse ranks
-  // based on the number of non-zero counts in the array and the number of non-zero
-  // counts in the other array. It returns 1/(number of non-zero counts in other array + 
-  // number of non-zero counts in this array/2)
-  
-  function calc_disjoint(N1, N2) { 
+  function calc_disjoint(N1, N2) {
     return( 1 / (N2 + N1/2) )
     }
-  
-  const inv_r1_disjoint = calc_disjoint(N1, N2); 
-  const inv_r2_disjoint = calc_disjoint(N2, N1); 
-  
+
+  const inv_r1_disjoint = calc_disjoint(N1, N2);
+  const inv_r2_disjoint = calc_disjoint(N2, N1);
+
   if (alpha === Infinity) {
-    
       return sum(indices1.map((i) => inv_r1[i])) + sum(indices2.map((i) => inv_r2[i]))
-    
   } else if (alpha === 0) {
       const term1 = sum(
         indices1.map((i) => Math.abs(Math.log(inv_r1[i] / inv_r2_disjoint)))
@@ -1726,9 +1729,9 @@ function norm_divElems(mixedelements, inv_r1, inv_r2, alpha) {
       const term2 = sum(
         indices2.map((i) => Math.abs(Math.log(inv_r2[i] / inv_r1_disjoint)))
       );
-      return term1 + term2 
+      return term1 + term2
   } else {
-      const term1 = (alpha+1)/alpha * sum( 
+      const term1 = (alpha+1)/alpha * sum(
         indices1.map((i) => inv_r1[i]).map( d => (Math.abs(d**alpha) - inv_r2_disjoint**alpha)**(1./(alpha+1) ))
       );
       const term2 = (alpha+1)/alpha * sum(
@@ -1738,33 +1741,63 @@ function norm_divElems(mixedelements, inv_r1, inv_r2, alpha) {
     }
 }
 
-// This function calculates the rank turbulence divergence for two arrays of mixed
-// elements, using the specified alpha value. It first calculates the arrays of
-// inverse ranks for each mixed element array and then calculates the divergence
-// and normalization factors using the divElems and norm_divElems functions. It
-// returns the divergence divided by the normalization.
-
-function rank_turbulence_divergence(mixedelements, alpha) {
-
+// JS implementation (fallback)
+function rank_turbulence_divergence_js(mixedelements, alpha) {
   const inv_r1 = mixedelements[0]['ranks'].map(d => Math.pow(d, -1));
   const inv_r2 = mixedelements[1]['ranks'].map(d => Math.pow(d, -1));
-  
+
   const divergence_elements = divElems(inv_r1, inv_r2, alpha);
   const normalization = norm_divElems(mixedelements, inv_r1, inv_r2, alpha);
-  
-  return { // the divergence used to wordshift dat to sort name in wordshift plot
-         // is equal to the formula in the upperleft of the diamond plot. However
-         // the formula is a proportionality and miss the normalization constant 
-         // shown here. 
-         // Example: for alpha = infinity, for the rank 1 names on both systems, the formula as written is equal to max(1/1, 1/former_rank) = 1/1 =1
-         // this value of 1 is then divided by the normalization constant.
-         // this constant of proportionality is the reason for the difference between the 1/1 that the written formula gives you
-         // and the decimal value that wordshift_dat states and which is actuallly used to sort the types.
-    'divergence_elements': divergence_elements.map(d => d / normalization), 
+
+  return {
+    'divergence_elements': divergence_elements.map(d => d / normalization),
     'normalization': normalization
   }
 }
 
+// Main export: SYNCHRONOUS - uses WASM if available, otherwise JS
+function rank_turbulence_divergence(mixedelements, alpha) {
+  // If WASM is loaded, use it
+  if (wasmInitialized && wasmModule) {
+    try {
+      // Call WASM implementation
+      const result = wasmModule.rank_turbulence_divergence(
+        mixedelements[0]['ranks'],
+        mixedelements[1]['ranks'],
+        mixedelements[0]['counts'],
+        mixedelements[1]['counts'],
+        alpha
+      );
+
+      // WASM returns a Map, convert to plain object to match expected interface
+      if (result instanceof Map) {
+        return {
+          divergence_elements: result.get('divergence_elements'),
+          normalization: result.get('normalization')
+        };
+      }
+
+      // Handle plain object (in case WASM serialization changes in the future)
+      if (result && typeof result === 'object' && result.divergence_elements) {
+        return {
+          divergence_elements: result.divergence_elements,
+          normalization: result.normalization
+        };
+      }
+
+      // Unexpected format, fall back to JS
+      console.warn('⚠️  WASM returned unexpected format, using JS fallback. Got:', result);
+      return rank_turbulence_divergence_js(mixedelements, alpha);
+    } catch (e) {
+      console.warn('⚠️  WASM execution failed, using JS fallback:', e);
+      return rank_turbulence_divergence_js(mixedelements, alpha);
+    }
+  } else {
+    // Use JS fallback
+    return rank_turbulence_divergence_js(mixedelements, alpha);
+  }
+}
+
 function rank2coord(rank) { return Math.floor(Math.log10(rank) / (1/15)) }
 
 // Augment information already in `me` class with coordinates. 
@@ -1883,8 +1916,14 @@ function diamond_count(mixedelements, wordshift) {
     }
     
     const counts = diamond_counts(mixedelements);
-  
-  return({'counts': counts, 'deltas': deltas, 'max_delta_loss': Math.max(...deltas_loss)})
+
+  // Find max manually to avoid stack overflow with large arrays
+  let max_delta_loss = deltas_loss[0];
+  for (let i = 1; i < deltas_loss.length; i++) {
+    if (deltas_loss[i] > max_delta_loss) max_delta_loss = deltas_loss[i];
+  }
+
+  return({'counts': counts, 'deltas': deltas, 'max_delta_loss': max_delta_loss})
 }
 
 /* allotaxonograph.svelte.ts generated by Svelte v5.34.3 */

package/dist/ssr/assets/allotaxonometer_wasm-BIgsRP_p.js

@@ -0,0 +1,300 @@
+let wasm;
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+let cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+let WASM_VECTOR_LEN = 0;
+const cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+  if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+    cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+  }
+  return cachedFloat64ArrayMemory0;
+}
+function passArrayF64ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 8, 8) >>> 0;
+  getFloat64ArrayMemory0().set(arg, ptr / 8);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function rank_turbulence_divergence(ranks1, ranks2, counts1, counts2, alpha) {
+  const ptr0 = passArrayF64ToWasm0(ranks1, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(ranks2, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passArrayF64ToWasm0(counts1, wasm.__wbindgen_malloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ptr3 = passArrayF64ToWasm0(counts2, wasm.__wbindgen_malloc);
+  const len3 = WASM_VECTOR_LEN;
+  const ret = wasm.rank_turbulence_divergence(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, alpha);
+  return ret;
+}
+const EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+        if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg_Error_e17e777aac105295 = function(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+  };
+  imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
+    const ret = new Object();
+    return ret;
+  };
+  imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
+    const ret = new Array();
+    return ret;
+  };
+  imports.wbg.__wbg_new_2ff1f68f3676ea53 = function() {
+    const ret = /* @__PURE__ */ new Map();
+    return ret;
+  };
+  imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+  };
+  imports.wbg.__wbg_set_90f6c0f7bd8c0415 = function(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+  };
+  imports.wbg.__wbg_set_b7f1cf4fae26fe2a = function(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
+    const ret = typeof arg0 === "string";
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    const ret = arg0;
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    const ret = arg0;
+    return ret;
+  };
+  imports.wbg.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_2;
+    const offset = table.grow(4);
+    table.set(0, void 0);
+    table.set(offset + 0, void 0);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+  };
+  return imports;
+}
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module;
+  cachedDataViewMemory0 = null;
+  cachedFloat64ArrayMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+function initSync(module) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module !== "undefined") {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (typeof module_or_path === "undefined") {
+    module_or_path = new URL("allotaxonometer_wasm_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+export {
+  __wbg_init as default,
+  initSync,
+  rank_turbulence_divergence
+};

package/dist/ssr/index.js

@@ -599,11 +599,17 @@ function tiedrank(arr) {
   return ranks;
 }
 function rank_maxlog10(mixedelements) {
-  let logged_max = [
-    Math.max(...mixedelements[[0]].ranks),
-    Math.max(...mixedelements[[1]].ranks)
-  ].map(Math.log10);
-  return Math.ceil(Math.max(...[logged_max[0], logged_max[1]]));
+  let max1 = mixedelements[[0]].ranks[0];
+  for (let i = 1; i < mixedelements[[0]].ranks.length; i++) {
+    if (mixedelements[[0]].ranks[i] > max1) max1 = mixedelements[[0]].ranks[i];
+  }
+  let max2 = mixedelements[[1]].ranks[0];
+  for (let i = 1; i < mixedelements[[1]].ranks.length; i++) {
+    if (mixedelements[[1]].ranks[i] > max2) max2 = mixedelements[[1]].ranks[i];
+  }
+  const logged_max1 = Math.log10(max1);
+  const logged_max2 = Math.log10(max2);
+  return Math.ceil(Math.max(logged_max1, logged_max2));
 }
 function rin(arr1, arr2) {
   return Array.from(arr1, (x) => {
@@ -704,6 +710,21 @@ function wordShift_dat(me, dat) {
   }
   return out.slice().sort((a, b) => descending(Math.abs(a.metric), Math.abs(b.metric)));
 }
+let wasmModule = null;
+let wasmInitialized = false;
+(async function initWASM() {
+  try {
+    const module = await import("./assets/allotaxonometer_wasm-BIgsRP_p.js");
+    await module.default();
+    wasmModule = module;
+    wasmInitialized = true;
+    console.log("✅ WASM module loaded successfully");
+  } catch (e) {
+    console.warn("⚠️  WASM not available, using JS fallback:", e.message);
+    wasmModule = null;
+    wasmInitialized = false;
+  }
+})();
 function divElems(inv_r1, inv_r2, alpha) {
   if (alpha === Infinity) {
     return inv_r1.map((d, i) => inv_r1[i] == inv_r2[i] ? 0 : Math.max(inv_r1[i], inv_r2[i]));
@@ -747,24 +768,48 @@ function norm_divElems(mixedelements, inv_r1, inv_r2, alpha) {
     return term1 + term2;
   }
 }
-function rank_turbulence_divergence(mixedelements, alpha) {
+function rank_turbulence_divergence_js(mixedelements, alpha) {
   const inv_r1 = mixedelements[0]["ranks"].map((d) => Math.pow(d, -1));
   const inv_r2 = mixedelements[1]["ranks"].map((d) => Math.pow(d, -1));
   const divergence_elements = divElems(inv_r1, inv_r2, alpha);
   const normalization = norm_divElems(mixedelements, inv_r1, inv_r2, alpha);
   return {
-    // the divergence used to wordshift dat to sort name in wordshift plot
-    // is equal to the formula in the upperleft of the diamond plot. However
-    // the formula is a proportionality and miss the normalization constant 
-    // shown here. 
-    // Example: for alpha = infinity, for the rank 1 names on both systems, the formula as written is equal to max(1/1, 1/former_rank) = 1/1 =1
-    // this value of 1 is then divided by the normalization constant.
-    // this constant of proportionality is the reason for the difference between the 1/1 that the written formula gives you
-    // and the decimal value that wordshift_dat states and which is actuallly used to sort the types.
     "divergence_elements": divergence_elements.map((d) => d / normalization),
     "normalization": normalization
   };
 }
+function rank_turbulence_divergence(mixedelements, alpha) {
+  if (wasmInitialized && wasmModule) {
+    try {
+      const result = wasmModule.rank_turbulence_divergence(
+        mixedelements[0]["ranks"],
+        mixedelements[1]["ranks"],
+        mixedelements[0]["counts"],
+        mixedelements[1]["counts"],
+        alpha
+      );
+      if (result instanceof Map) {
+        return {
+          divergence_elements: result.get("divergence_elements"),
+          normalization: result.get("normalization")
+        };
+      }
+      if (result && typeof result === "object" && result.divergence_elements) {
+        return {
+          divergence_elements: result.divergence_elements,
+          normalization: result.normalization
+        };
+      }
+      console.warn("⚠️  WASM returned unexpected format, using JS fallback. Got:", result);
+      return rank_turbulence_divergence_js(mixedelements, alpha);
+    } catch (e) {
+      console.warn("⚠️  WASM execution failed, using JS fallback:", e);
+      return rank_turbulence_divergence_js(mixedelements, alpha);
+    }
+  } else {
+    return rank_turbulence_divergence_js(mixedelements, alpha);
+  }
+}
 function rank2coord(rank) {
   return Math.floor(Math.log10(rank) / (1 / 15));
 }
@@ -861,7 +906,11 @@ function diamond_count(mixedelements, wordshift) {
     if (mixedelements[1]["ranks"][i] < mixedelements[0]["ranks"][i]) ;
   }
   const counts = diamond_counts(mixedelements);
-  return { "counts": counts, "deltas": deltas, "max_delta_loss": Math.max(...deltas_loss) };
+  let max_delta_loss = deltas_loss[0];
+  for (let i = 1; i < deltas_loss.length; i++) {
+    if (deltas_loss[i] > max_delta_loss) max_delta_loss = deltas_loss[i];
+  }
+  return { "counts": counts, "deltas": deltas, "max_delta_loss": max_delta_loss };
 }
 class Allotaxonograph {
   // Core data state

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allotaxonometer-ui",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Headless UI components for allotaxonometer visualizations built with Svelte 5",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,9 +53,10 @@
     "vitest": "^3.2.3"
   },
   "scripts": {
-    "build": "vite build",
+    "build:wasm": "cd rust-wasm && wasm-pack build --target web --out-dir ../src/lib/utils/wasm",
+    "build": "npm run build:wasm && vite build",
     "build:ssr": "vite build --config vite.ssr.config.js",
-    "build:all": "npm run build && npm run build:ssr",
+    "build:all": "npm run build:wasm && npm run build && npm run build:ssr",
     "test": "vitest",
     "test:run": "vitest run",
     "test:ssr": "npm run build:ssr && vitest run tests/ssr.test.js",