@datagrok/eda 1.4.2 → 1.4.4

package/dist/vendors-node_modules_datagrok-libraries_math_src_hierarchical-clustering_wasm_clustering-worker_js.js

@@ -0,0 +1,942 @@
+var eda;
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/clusterizerWasm.js":
+/*!***************************************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/clusterizerWasm.js ***!
+  \***************************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getClustersFromDistMatWasm: () => (/* binding */ getClustersFromDistMatWasm)
+/* harmony export */ });
+/* harmony import */ var _wasmCluster_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./wasmCluster.js */ "./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/wasmCluster.js");
+
+
+/**
+ calls wasm function to get clustering merges and heights from distance matrix
+ distmat: distance matrix as an array of floats comprising the top right triangle of the matrix
+ n: number of observables
+ method: 0 = single linkage, 1 = complete linkage, 2 = average linkage, 3 = median linkage
+ result: { mergeResult: Int32Array, heightsResult: Float32Array }
+ mergeResult has length of (n-1)*2 and heightResult has length of n-1
+ together they describe the clustering as a dendrogram as a matrix of (n-1) X 3
+ each row in the given matrix comprises the merge event at step i and last column is the height from the leaves.
+*/
+async function getClustersFromDistMatWasm(distmat, n, method) {
+  const wasmUrl = new URL(/* asset import */ __webpack_require__(/*! ./wasmCluster.wasm */ "./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/wasmCluster.wasm"), __webpack_require__.b).href;
+  const wasmPath = wasmUrl.substring(0, wasmUrl.lastIndexOf('/') + 1) + 'wasmCluster.wasm';
+  let wasmInstance;
+  try {
+      wasmInstance = await (0,_wasmCluster_js__WEBPACK_IMPORTED_MODULE_0__.exportCppLib)({locateFile: () => wasmPath, printErr: (_) => {}});
+  } catch (e) {
+      try {
+          wasmInstance = await (0,_wasmCluster_js__WEBPACK_IMPORTED_MODULE_0__.exportCppLib)({locateFile: () => wasmUrl, printErr: (_) => {}});
+      }
+      catch (e) {
+          console.error(e);
+          throw new Error('Unable to load wasm file for hierarchical clustering');
+      }
+  }
+
+  const getDendrogramWasm =
+    wasmInstance.cwrap('getDendrogram', 'null', ['number', 'number', 'number', 'number', 'number']);
+  // allocate a memory block on the wasm heap for the distance matrix
+  const bytesForDistMat = Float32Array.BYTES_PER_ELEMENT * distmat.length;
+  const dataPtr = wasmInstance._malloc(bytesForDistMat);
+  const matHeap = new Uint8Array(wasmInstance.HEAPU8.buffer, dataPtr, bytesForDistMat);
+  matHeap.set(new Uint8Array(distmat.buffer));
+
+  //allocate a memory block on the wasm heap for the merges array
+  const bytesForMergeArray = Int32Array.BYTES_PER_ELEMENT * (n - 1) * 2;
+  const mergePtr = wasmInstance._malloc(bytesForMergeArray);
+  const mergeHeap = new Uint8Array(wasmInstance.HEAPU8.buffer, mergePtr, bytesForMergeArray);
+
+  //allocate a memory block on the wasm heap for the heigt array
+  const bytesForHeightsArray = Float32Array.BYTES_PER_ELEMENT * (n - 1);
+  const heightsPtr = wasmInstance._malloc(bytesForHeightsArray);
+  const heightsHeap = new Uint8Array(wasmInstance.HEAPU8.buffer, heightsPtr, bytesForHeightsArray);
+
+  // call the wasm function
+  getDendrogramWasm(dataPtr, n, method, mergePtr, heightsPtr);
+  // get the merges and heights from the wasm heap
+  const mergeResult = new Int32Array(mergeHeap.buffer, mergeHeap.byteOffset, (n-1) * 2);
+  const heightsResult = (new Float32Array(heightsHeap.buffer, heightsHeap.byteOffset, n-1)).slice(0, n-1);
+
+  const mergeRow1 = mergeResult.slice(0, n-1);
+  const mergeRow2 = mergeResult.slice(n-1, 2*n - 2);
+  // free the memory blocks on the wasm heap
+  wasmInstance._free(matHeap.byteOffset);
+  wasmInstance._free(mergeHeap.byteOffset);
+  wasmInstance._free(heightsHeap.byteOffset);
+  return {mergeRow1, mergeRow2, heightsResult};
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/wasmCluster.js":
+/*!***********************************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/wasmCluster.js ***!
+  \***********************************************************************************************/
+/***/ ((module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   exportCppLib: () => (/* binding */ exportCppLib)
+/* harmony export */ });
+/* module decorator */ module = __webpack_require__.hmd(module);
+var exportCppLib = (() => {
+  var _scriptDir =
+    typeof document !== "undefined" && document.currentScript
+      ? document.currentScript.src
+      : undefined;
+
+  return function (exportCppLib = {}) {
+    var Module = typeof exportCppLib != "undefined" ? exportCppLib : {};
+    var readyPromiseResolve, readyPromiseReject;
+    Module["ready"] = new Promise(function (resolve, reject) {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+    var moduleOverrides = Object.assign({}, Module);
+    var arguments_ = [];
+    var thisProgram = "./this.program";
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    var ENVIRONMENT_IS_WEB = typeof window == "object";
+    var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
+    var ENVIRONMENT_IS_NODE =
+      typeof process == "object" &&
+      typeof process.versions == "object" &&
+      typeof process.versions.node == "string";
+    var scriptDirectory = "";
+    function locateFile(path) {
+      if (Module["locateFile"]) {
+        return Module["locateFile"](path, scriptDirectory);
+      }
+      return scriptDirectory + path;
+    }
+    var read_, readAsync, readBinary, setWindowTitle;
+    if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+      if (ENVIRONMENT_IS_WORKER) {
+        scriptDirectory = self.location.href;
+      } else if (typeof document != "undefined" && document.currentScript) {
+        scriptDirectory = document.currentScript.src;
+      }
+      if (_scriptDir) {
+        scriptDirectory = _scriptDir;
+      }
+      if (scriptDirectory.indexOf("blob:") !== 0) {
+        scriptDirectory = scriptDirectory.substr(
+          0,
+          scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1
+        );
+      } else {
+        scriptDirectory = "";
+      }
+      {
+        read_ = (url) => {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", url, false);
+          xhr.send(null);
+          return xhr.responseText;
+        };
+        if (ENVIRONMENT_IS_WORKER) {
+          readBinary = (url) => {
+            var xhr = new XMLHttpRequest();
+            xhr.open("GET", url, false);
+            xhr.responseType = "arraybuffer";
+            xhr.send(null);
+            return new Uint8Array(xhr.response);
+          };
+        }
+        readAsync = (url, onload, onerror) => {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", url, true);
+          xhr.responseType = "arraybuffer";
+          xhr.onload = () => {
+            if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+              onload(xhr.response);
+              return;
+            }
+            onerror();
+          };
+          xhr.onerror = onerror;
+          xhr.send(null);
+        };
+      }
+      setWindowTitle = (title) => (document.title = title);
+    } else {
+    }
+    var out = Module["print"] || console.log.bind(console);
+    var err = Module["printErr"] || console.warn.bind(console);
+    Object.assign(Module, moduleOverrides);
+    moduleOverrides = null;
+    if (Module["arguments"]) arguments_ = Module["arguments"];
+    if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+    if (Module["quit"]) quit_ = Module["quit"];
+    var wasmBinary;
+    if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+    var noExitRuntime = Module["noExitRuntime"] || true;
+    if (typeof WebAssembly != "object") {
+      abort("no native wasm support detected");
+    }
+    var wasmMemory;
+    var ABORT = false;
+    var EXITSTATUS;
+    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      Module["HEAP8"] = HEAP8 = new Int8Array(b);
+      Module["HEAP16"] = HEAP16 = new Int16Array(b);
+      Module["HEAP32"] = HEAP32 = new Int32Array(b);
+      Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+      Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
+      Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+      Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
+      Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
+    }
+    var wasmTable;
+    var __ATPRERUN__ = [];
+    var __ATINIT__ = [];
+    var __ATPOSTRUN__ = [];
+    var runtimeInitialized = false;
+    function preRun() {
+      if (Module["preRun"]) {
+        if (typeof Module["preRun"] == "function")
+          Module["preRun"] = [Module["preRun"]];
+        while (Module["preRun"].length) {
+          addOnPreRun(Module["preRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(__ATPRERUN__);
+    }
+    function initRuntime() {
+      runtimeInitialized = true;
+      callRuntimeCallbacks(__ATINIT__);
+    }
+    function postRun() {
+      if (Module["postRun"]) {
+        if (typeof Module["postRun"] == "function")
+          Module["postRun"] = [Module["postRun"]];
+        while (Module["postRun"].length) {
+          addOnPostRun(Module["postRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(__ATPOSTRUN__);
+    }
+    function addOnPreRun(cb) {
+      __ATPRERUN__.unshift(cb);
+    }
+    function addOnInit(cb) {
+      __ATINIT__.unshift(cb);
+    }
+    function addOnPostRun(cb) {
+      __ATPOSTRUN__.unshift(cb);
+    }
+    var runDependencies = 0;
+    var runDependencyWatcher = null;
+    var dependenciesFulfilled = null;
+    function addRunDependency(id) {
+      runDependencies++;
+      if (Module["monitorRunDependencies"]) {
+        Module["monitorRunDependencies"](runDependencies);
+      }
+    }
+    function removeRunDependency(id) {
+      runDependencies--;
+      if (Module["monitorRunDependencies"]) {
+        Module["monitorRunDependencies"](runDependencies);
+      }
+      if (runDependencies == 0) {
+        if (runDependencyWatcher !== null) {
+          clearInterval(runDependencyWatcher);
+          runDependencyWatcher = null;
+        }
+        if (dependenciesFulfilled) {
+          var callback = dependenciesFulfilled;
+          dependenciesFulfilled = null;
+          callback();
+        }
+      }
+    }
+    function abort(what) {
+      if (Module["onAbort"]) {
+        Module["onAbort"](what);
+      }
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      EXITSTATUS = 1;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject(e);
+      throw e;
+    }
+    var dataURIPrefix = "data:application/octet-stream;base64,";
+    function isDataURI(filename) {
+      return filename.startsWith(dataURIPrefix);
+    }
+    var wasmBinaryFile;
+    wasmBinaryFile = "wasmCluster.wasm";
+    if (!isDataURI(wasmBinaryFile)) {
+      wasmBinaryFile = locateFile(wasmBinaryFile);
+    }
+    function getBinary(file) {
+      try {
+        if (file == wasmBinaryFile && wasmBinary) {
+          return new Uint8Array(wasmBinary);
+        }
+        if (readBinary) {
+          return readBinary(file);
+        }
+        throw "both async and sync fetching of the wasm failed";
+      } catch (err) {
+        abort(err);
+      }
+    }
+    function getBinaryPromise(binaryFile) {
+      if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+        if (typeof fetch == "function") {
+          return fetch(binaryFile, { credentials: "same-origin" })
+            .then(function (response) {
+              if (!response["ok"]) {
+                throw "failed to load wasm binary file at '" + binaryFile + "'";
+              }
+              return response["arrayBuffer"]();
+            })
+            .catch(function () {
+              return getBinary(binaryFile);
+            });
+        }
+      }
+      return Promise.resolve().then(function () {
+        return getBinary(binaryFile);
+      });
+    }
+    function instantiateArrayBuffer(binaryFile, imports, receiver) {
+      return getBinaryPromise(binaryFile)
+        .then(function (binary) {
+          return WebAssembly.instantiate(binary, imports);
+        })
+        .then(function (instance) {
+          return instance;
+        })
+        .then(receiver, function (reason) {
+          err("failed to asynchronously prepare wasm: " + reason);
+          abort(reason);
+        });
+    }
+    function instantiateAsync(binary, binaryFile, imports, callback) {
+      if (
+        !binary &&
+        typeof WebAssembly.instantiateStreaming == "function" &&
+        !isDataURI(binaryFile) &&
+        typeof fetch == "function"
+      ) {
+        return fetch(binaryFile, { credentials: "same-origin" }).then(function (
+          response
+        ) {
+          var result = WebAssembly.instantiateStreaming(response, imports);
+          return result.then(callback, function (reason) {
+            err("wasm streaming compile failed: " + reason);
+            err("falling back to ArrayBuffer instantiation");
+            return instantiateArrayBuffer(binaryFile, imports, callback);
+          });
+        });
+      } else {
+        return instantiateArrayBuffer(binaryFile, imports, callback);
+      }
+    }
+    function createWasm() {
+      var info = { a: wasmImports };
+      function receiveInstance(instance, module) {
+        var exports = instance.exports;
+        Module["asm"] = exports;
+        wasmMemory = Module["asm"]["e"];
+        updateMemoryViews();
+        wasmTable = Module["asm"]["i"];
+        addOnInit(Module["asm"]["f"]);
+        removeRunDependency("wasm-instantiate");
+        return exports;
+      }
+      addRunDependency("wasm-instantiate");
+      function receiveInstantiationResult(result) {
+        receiveInstance(result["instance"]);
+      }
+      if (Module["instantiateWasm"]) {
+        try {
+          return Module["instantiateWasm"](info, receiveInstance);
+        } catch (e) {
+          err("Module.instantiateWasm callback failed with error: " + e);
+          readyPromiseReject(e);
+        }
+      }
+      instantiateAsync(
+        wasmBinary,
+        wasmBinaryFile,
+        info,
+        receiveInstantiationResult
+      ).catch(readyPromiseReject);
+      return {};
+    }
+    function callRuntimeCallbacks(callbacks) {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    }
+    function ExceptionInfo(excPtr) {
+      this.excPtr = excPtr;
+      this.ptr = excPtr - 24;
+      this.set_type = function (type) {
+        HEAPU32[(this.ptr + 4) >> 2] = type;
+      };
+      this.get_type = function () {
+        return HEAPU32[(this.ptr + 4) >> 2];
+      };
+      this.set_destructor = function (destructor) {
+        HEAPU32[(this.ptr + 8) >> 2] = destructor;
+      };
+      this.get_destructor = function () {
+        return HEAPU32[(this.ptr + 8) >> 2];
+      };
+      this.set_caught = function (caught) {
+        caught = caught ? 1 : 0;
+        HEAP8[(this.ptr + 12) >> 0] = caught;
+      };
+      this.get_caught = function () {
+        return HEAP8[(this.ptr + 12) >> 0] != 0;
+      };
+      this.set_rethrown = function (rethrown) {
+        rethrown = rethrown ? 1 : 0;
+        HEAP8[(this.ptr + 13) >> 0] = rethrown;
+      };
+      this.get_rethrown = function () {
+        return HEAP8[(this.ptr + 13) >> 0] != 0;
+      };
+      this.init = function (type, destructor) {
+        this.set_adjusted_ptr(0);
+        this.set_type(type);
+        this.set_destructor(destructor);
+      };
+      this.set_adjusted_ptr = function (adjustedPtr) {
+        HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr;
+      };
+      this.get_adjusted_ptr = function () {
+        return HEAPU32[(this.ptr + 16) >> 2];
+      };
+      this.get_exception_ptr = function () {
+        var isPointer = ___cxa_is_pointer_type(this.get_type());
+        if (isPointer) {
+          return HEAPU32[this.excPtr >> 2];
+        }
+        var adjusted = this.get_adjusted_ptr();
+        if (adjusted !== 0) return adjusted;
+        return this.excPtr;
+      };
+    }
+    var exceptionLast = 0;
+    var uncaughtExceptionCount = 0;
+    function ___cxa_throw(ptr, type, destructor) {
+      var info = new ExceptionInfo(ptr);
+      info.init(type, destructor);
+      exceptionLast = ptr;
+      uncaughtExceptionCount++;
+      throw exceptionLast;
+    }
+    function _abort() {
+      abort("");
+    }
+    function _emscripten_memcpy_big(dest, src, num) {
+      HEAPU8.copyWithin(dest, src, src + num);
+    }
+    function getHeapMax() {
+      return 2147483648;
+    }
+    function emscripten_realloc_buffer(size) {
+      var b = wasmMemory.buffer;
+      try {
+        wasmMemory.grow((size - b.byteLength + 65535) >>> 16);
+        updateMemoryViews();
+        return 1;
+      } catch (e) {}
+    }
+    function _emscripten_resize_heap(requestedSize) {
+      var oldSize = HEAPU8.length;
+      requestedSize = requestedSize >>> 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        return false;
+      }
+      let alignUp = (x, multiple) =>
+        x + ((multiple - (x % multiple)) % multiple);
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+        overGrownHeapSize = Math.min(
+          overGrownHeapSize,
+          requestedSize + 100663296
+        );
+        var newSize = Math.min(
+          maxHeapSize,
+          alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)
+        );
+        var replacement = emscripten_realloc_buffer(newSize);
+        if (replacement) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function getCFunc(ident) {
+      var func = Module["_" + ident];
+      return func;
+    }
+    function writeArrayToMemory(array, buffer) {
+      HEAP8.set(array, buffer);
+    }
+    function lengthBytesUTF8(str) {
+      var len = 0;
+      for (var i = 0; i < str.length; ++i) {
+        var c = str.charCodeAt(i);
+        if (c <= 127) {
+          len++;
+        } else if (c <= 2047) {
+          len += 2;
+        } else if (c >= 55296 && c <= 57343) {
+          len += 4;
+          ++i;
+        } else {
+          len += 3;
+        }
+      }
+      return len;
+    }
+    function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+      if (!(maxBytesToWrite > 0)) return 0;
+      var startIdx = outIdx;
+      var endIdx = outIdx + maxBytesToWrite - 1;
+      for (var i = 0; i < str.length; ++i) {
+        var u = str.charCodeAt(i);
+        if (u >= 55296 && u <= 57343) {
+          var u1 = str.charCodeAt(++i);
+          u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
+        }
+        if (u <= 127) {
+          if (outIdx >= endIdx) break;
+          heap[outIdx++] = u;
+        } else if (u <= 2047) {
+          if (outIdx + 1 >= endIdx) break;
+          heap[outIdx++] = 192 | (u >> 6);
+          heap[outIdx++] = 128 | (u & 63);
+        } else if (u <= 65535) {
+          if (outIdx + 2 >= endIdx) break;
+          heap[outIdx++] = 224 | (u >> 12);
+          heap[outIdx++] = 128 | ((u >> 6) & 63);
+          heap[outIdx++] = 128 | (u & 63);
+        } else {
+          if (outIdx + 3 >= endIdx) break;
+          heap[outIdx++] = 240 | (u >> 18);
+          heap[outIdx++] = 128 | ((u >> 12) & 63);
+          heap[outIdx++] = 128 | ((u >> 6) & 63);
+          heap[outIdx++] = 128 | (u & 63);
+        }
+      }
+      heap[outIdx] = 0;
+      return outIdx - startIdx;
+    }
+    function stringToUTF8(str, outPtr, maxBytesToWrite) {
+      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+    }
+    function stringToUTF8OnStack(str) {
+      var size = lengthBytesUTF8(str) + 1;
+      var ret = stackAlloc(size);
+      stringToUTF8(str, ret, size);
+      return ret;
+    }
+    var UTF8Decoder =
+      typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
+    function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+      var endIdx = idx + maxBytesToRead;
+      var endPtr = idx;
+      while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+      }
+      var str = "";
+      while (idx < endPtr) {
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 128)) {
+          str += String.fromCharCode(u0);
+          continue;
+        }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 224) == 192) {
+          str += String.fromCharCode(((u0 & 31) << 6) | u1);
+          continue;
+        }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 240) == 224) {
+          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+        } else {
+          u0 =
+            ((u0 & 7) << 18) |
+            (u1 << 12) |
+            (u2 << 6) |
+            (heapOrArray[idx++] & 63);
+        }
+        if (u0 < 65536) {
+          str += String.fromCharCode(u0);
+        } else {
+          var ch = u0 - 65536;
+          str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+        }
+      }
+      return str;
+    }
+    function UTF8ToString(ptr, maxBytesToRead) {
+      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+    }
+    function ccall(ident, returnType, argTypes, args, opts) {
+      var toC = {
+        string: (str) => {
+          var ret = 0;
+          if (str !== null && str !== undefined && str !== 0) {
+            ret = stringToUTF8OnStack(str);
+          }
+          return ret;
+        },
+        array: (arr) => {
+          var ret = stackAlloc(arr.length);
+          writeArrayToMemory(arr, ret);
+          return ret;
+        },
+      };
+      function convertReturnValue(ret) {
+        if (returnType === "string") {
+          return UTF8ToString(ret);
+        }
+        if (returnType === "boolean") return Boolean(ret);
+        return ret;
+      }
+      var func = getCFunc(ident);
+      var cArgs = [];
+      var stack = 0;
+      if (args) {
+        for (var i = 0; i < args.length; i++) {
+          var converter = toC[argTypes[i]];
+          if (converter) {
+            if (stack === 0) stack = stackSave();
+            cArgs[i] = converter(args[i]);
+          } else {
+            cArgs[i] = args[i];
+          }
+        }
+      }
+      var ret = func.apply(null, cArgs);
+      function onDone(ret) {
+        if (stack !== 0) stackRestore(stack);
+        return convertReturnValue(ret);
+      }
+      ret = onDone(ret);
+      return ret;
+    }
+    function cwrap(ident, returnType, argTypes, opts) {
+      var numericArgs =
+        !argTypes ||
+        argTypes.every((type) => type === "number" || type === "boolean");
+      var numericRet = returnType !== "string";
+      if (numericRet && numericArgs && !opts) {
+        return getCFunc(ident);
+      }
+      return function () {
+        return ccall(ident, returnType, argTypes, arguments, opts);
+      };
+    }
+    var wasmImports = {
+      d: ___cxa_throw,
+      a: _abort,
+      c: _emscripten_memcpy_big,
+      b: _emscripten_resize_heap,
+    };
+    var asm = createWasm();
+    var ___wasm_call_ctors = function () {
+      return (___wasm_call_ctors = Module["asm"]["f"]).apply(null, arguments);
+    };
+    var _getDendrogram = (Module["_getDendrogram"] = function () {
+      return (_getDendrogram = Module["_getDendrogram"] =
+        Module["asm"]["g"]).apply(null, arguments);
+    });
+    var _free = (Module["_free"] = function () {
+      return (_free = Module["_free"] = Module["asm"]["h"]).apply(
+        null,
+        arguments
+      );
+    });
+    var ___errno_location = function () {
+      return (___errno_location = Module["asm"]["__errno_location"]).apply(
+        null,
+        arguments
+      );
+    };
+    var _malloc = (Module["_malloc"] = function () {
+      return (_malloc = Module["_malloc"] = Module["asm"]["j"]).apply(
+        null,
+        arguments
+      );
+    });
+    var stackSave = function () {
+      return (stackSave = Module["asm"]["k"]).apply(null, arguments);
+    };
+    var stackRestore = function () {
+      return (stackRestore = Module["asm"]["l"]).apply(null, arguments);
+    };
+    var stackAlloc = function () {
+      return (stackAlloc = Module["asm"]["m"]).apply(null, arguments);
+    };
+    var ___cxa_is_pointer_type = function () {
+      return (___cxa_is_pointer_type = Module["asm"]["n"]).apply(
+        null,
+        arguments
+      );
+    };
+    Module["ccall"] = ccall;
+    Module["cwrap"] = cwrap;
+    var calledRun;
+    dependenciesFulfilled = function runCaller() {
+      if (!calledRun) run();
+      if (!calledRun) dependenciesFulfilled = runCaller;
+    };
+    function run() {
+      if (runDependencies > 0) {
+        return;
+      }
+      preRun();
+      if (runDependencies > 0) {
+        return;
+      }
+      function doRun() {
+        if (calledRun) return;
+        calledRun = true;
+        Module["calledRun"] = true;
+        if (ABORT) return;
+        initRuntime();
+        readyPromiseResolve(Module);
+        if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
+        postRun();
+      }
+      if (Module["setStatus"]) {
+        Module["setStatus"]("Running...");
+        setTimeout(function () {
+          setTimeout(function () {
+            Module["setStatus"]("");
+          }, 1);
+          doRun();
+        }, 1);
+      } else {
+        doRun();
+      }
+    }
+    if (Module["preInit"]) {
+      if (typeof Module["preInit"] == "function")
+        Module["preInit"] = [Module["preInit"]];
+      while (Module["preInit"].length > 0) {
+        Module["preInit"].pop()();
+      }
+    }
+    run();
+
+    return exportCppLib.ready;
+  };
+})();
+if (typeof exports === "object" && "object" === "object")
+  module.exports = exportCppLib;
+else if (typeof define === "function" && __webpack_require__.amdO)
+  define([], function () {
+    return exportCppLib;
+  });
+else if (typeof exports === "object") exports["exportCppLib"] = exportCppLib;
+
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/wasmCluster.wasm":
+/*!*************************************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/wasmCluster.wasm ***!
+  \*************************************************************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__.p + "8473fcbfb6e85ca6c852.wasm";
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			id: moduleId,
+/******/ 			loaded: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/amd options */
+/******/ 	(() => {
+/******/ 		__webpack_require__.amdO = {};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/harmony module decorator */
+/******/ 	(() => {
+/******/ 		__webpack_require__.hmd = (module) => {
+/******/ 			module = Object.create(module);
+/******/ 			if (!module.children) module.children = [];
+/******/ 			Object.defineProperty(module, 'exports', {
+/******/ 				enumerable: true,
+/******/ 				set: () => {
+/******/ 					throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);
+/******/ 				}
+/******/ 			});
+/******/ 			return module;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	(() => {
+/******/ 		var scriptUrl;
+/******/ 		if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+/******/ 		var document = __webpack_require__.g.document;
+/******/ 		if (!scriptUrl && document) {
+/******/ 			if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')
+/******/ 				scriptUrl = document.currentScript.src;
+/******/ 			if (!scriptUrl) {
+/******/ 				var scripts = document.getElementsByTagName("script");
+/******/ 				if(scripts.length) {
+/******/ 					var i = scripts.length - 1;
+/******/ 					while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;
+/******/ 				}
+/******/ 			}
+/******/ 		}
+/******/ 		// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
+/******/ 		// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
+/******/ 		if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+/******/ 		scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+/******/ 		__webpack_require__.p = scriptUrl;
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/importScripts chunk loading */
+/******/ 	(() => {
+/******/ 		__webpack_require__.b = self.location + "";
+/******/ 		
+/******/ 		// object to store loaded chunks
+/******/ 		// "1" means "already loaded"
+/******/ 		var installedChunks = {
+/******/ 			"vendors-node_modules_datagrok-libraries_math_src_hierarchical-clustering_wasm_clustering-worker_js": 1
+/******/ 		};
+/******/ 		
+/******/ 		// no chunk install function needed
+/******/ 		// no chunk loading
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+/*!*****************************************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/clustering-worker.js ***!
+  \*****************************************************************************************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _clusterizerWasm__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./clusterizerWasm */ "./node_modules/@datagrok-libraries/math/src/hierarchical-clustering/wasm/clusterizerWasm.js");
+
+onmessage = (event) => {
+    const { distMatArray, n, methodCode } = event.data;
+    const data = {};
+    try {
+        (0,_clusterizerWasm__WEBPACK_IMPORTED_MODULE_0__.getClustersFromDistMatWasm)(distMatArray, n, methodCode)
+            .then((clusterMatrix) => {
+            data.clusterMatrix = clusterMatrix;
+            postMessage(data);
+        });
+    }
+    catch (e) {
+        data.error = e;
+        postMessage(data);
+    }
+};
+//# sourceMappingURL=clustering-worker.js.map
+})();
+
+eda = __webpack_exports__;
+/******/ })()
+;
+//# sourceMappingURL=vendors-node_modules_datagrok-libraries_math_src_hierarchical-clustering_wasm_clustering-worker_js.js.map