@datagrok/eda 1.4.2 → 1.4.4

package/dist/vendors-node_modules_datagrok-libraries_ml_src_MCL_mcl-worker_js-node_modules_datagrok-librar-e4203d.js

@@ -0,0 +1,2244 @@
+var eda;
+/******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./node_modules/@datagrok-libraries/ml/src/MCL/clustering-steps.js":
+/*!*************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/ml/src/MCL/clustering-steps.js ***!
+  \*************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   colwiseNormilize: () => (/* binding */ colwiseNormilize),
+/* harmony export */   initMCLMatrix: () => (/* binding */ initMCLMatrix),
+/* harmony export */   mclInflate: () => (/* binding */ mclInflate),
+/* harmony export */   prune: () => (/* binding */ prune),
+/* harmony export */   runMarkovClustering: () => (/* binding */ runMarkovClustering)
+/* harmony export */ });
+/* harmony import */ var _mcl_sparse_matrix_mult__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./mcl-sparse-matrix-mult */ "./node_modules/@datagrok-libraries/ml/src/MCL/mcl-sparse-matrix-mult.js");
+
+function prune(sparseMatrix, pruneValue) {
+    const is = [];
+    const js = [];
+    const ds = [];
+    for (let i = 0; i < sparseMatrix.i.length; i++) {
+        if (sparseMatrix.distance[i] > pruneValue) {
+            is.push(sparseMatrix.i[i]);
+            js.push(sparseMatrix.j[i]);
+            ds.push(sparseMatrix.distance[i]);
+        }
+    }
+    return { i: new Uint32Array(is), j: new Uint32Array(js), distance: new Float32Array(ds) };
+}
+function mclInflate(sparseMatrix, pow) {
+    const d = sparseMatrix.distance;
+    for (let i = 0; i < sparseMatrix.i.length; i++)
+        d[i] = Math.pow(d[i], pow);
+    return sparseMatrix;
+}
+function colwiseNormilize(sparseMatrix, nRows, pruneValue, doPrune) {
+    if (doPrune)
+        sparseMatrix = prune(sparseMatrix, pruneValue);
+    const colSums = new Float32Array(nRows);
+    const d = sparseMatrix.distance;
+    const js = sparseMatrix.j;
+    for (let i = 0; i < sparseMatrix.i.length; i++)
+        colSums[js[i]] += d[i];
+    for (let i = 0; i < sparseMatrix.i.length; i++) {
+        const sum = colSums[js[i]];
+        if (sum !== 0)
+            d[i] /= sum;
+    }
+    return sparseMatrix;
+}
+function initMCLMatrix(sparseMatrix, nRows, pruneValue) {
+    // here we get sparse matrix that is only a half of the matrix
+    // also, the matrix contains distances, need to convert those into similarities
+    // also, we need to add self loops
+    const is = new Uint32Array(sparseMatrix.i.length * 2 + nRows);
+    const js = new Uint32Array(sparseMatrix.j.length * 2 + nRows);
+    const ds = new Float32Array(sparseMatrix.distance.length * 2 + nRows);
+    for (let i = 0; i < nRows; i++) {
+        is[i] = i;
+        js[i] = i;
+        ds[i] = 1;
+    }
+    for (let i = 0; i < sparseMatrix.i.length; i++) {
+        const start = i * 2 + nRows;
+        is[start] = sparseMatrix.i[i];
+        js[start] = sparseMatrix.j[i];
+        ds[start] = 1 - sparseMatrix.distance[i];
+        is[start + 1] = sparseMatrix.j[i];
+        js[start + 1] = sparseMatrix.i[i];
+        ds[start + 1] = 1 - sparseMatrix.distance[i];
+    }
+    // normalize
+    colwiseNormilize({ i: is, j: js, distance: ds }, nRows, pruneValue, false);
+    return { i: is, j: js, distance: ds };
+}
+async function runMarkovClustering(sparseMatrix, nRows, inflate, maxIter, pruneValue) {
+    let matrix = initMCLMatrix(sparseMatrix, nRows, pruneValue);
+    for (let i = 0; i < maxIter; i++) {
+        matrix = await (0,_mcl_sparse_matrix_mult__WEBPACK_IMPORTED_MODULE_0__.multSparseMatrix)(matrix, nRows, pruneValue);
+        // console.time('inflate');
+        //@ts-ignore
+        matrix = colwiseNormilize(matrix, nRows, pruneValue, false);
+        matrix = mclInflate(matrix, inflate);
+        //@ts-ignore
+        matrix = colwiseNormilize(matrix, nRows, pruneValue, true);
+        console.log('MCL iteration', i);
+    }
+    return matrix;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clustering-steps.js","sourceRoot":"","sources":["clustering-steps.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAE1D,MAAM,UAAU,KAAK,CAAC,YAA0B,EAAE,UAAkB;IAClE,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/C,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,UAAU,EAAE,CAAC;YAC1C,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3B,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3B,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IACD,OAAO,EAAC,CAAC,EAAE,IAAI,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,WAAW,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,YAAY,CAAC,EAAE,CAAC,EAAC,CAAC;AAC1F,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,YAA0B,EAAE,GAAW;IAChE,MAAM,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC;IAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE;QAC5C,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAE7B,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,YAA0B,EAAE,KAAa,EAAE,UAAkB,EAAE,OAAiB;IAEhF,IAAI,OAAO;QACT,YAAY,GAAG,KAAK,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IAEjD,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;IACxC,MAAM,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC;IAChC,MAAM,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC;IAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE;QAC5C,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/C,MAAM,GAAG,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,IAAI,GAAG,KAAK,CAAC;YACX,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;IAChB,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,YAA0B,EAAE,KAAa,EAAE,UAAkB;IACzF,8DAA8D;IAC9D,+EAA+E;IAC/E,kCAAkC;IAClC,MAAM,EAAE,GAAG,IAAI,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;IAC9D,MAAM,EAAE,GAAG,IAAI,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;IAC9D,MAAM,EAAE,GAAG,IAAI,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;IACtE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACV,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACV,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACZ,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/C,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QAC5B,EAAE,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9B,EAAE,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9B,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAEzC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED,YAAY;IACZ,gBAAgB,CAAC,EAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAC,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;IAEzE,OAAO,EAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAC,CAAC;AACtC,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,YAA0B,EAAE,KAAa,EAAE,OAAe,EAAE,OAAe,EAAE,UAAkB;IAE/F,IAAI,MAAM,GAAG,aAAa,CAAC,YAAY,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;IAC5D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;QACjC,MAAM,GAAG,MAAM,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;QAC3D,2BAA2B;QAC3B,YAAY;QACZ,MAAM,GAAG,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;QAC5D,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAErC,YAAY;QACZ,MAAM,GAAG,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;QAC3D,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import {SparseMatrix} from '@datagrok-libraries/math';\nimport {multSparseMatrix} from './mcl-sparse-matrix-mult';\n\nexport function prune(sparseMatrix: SparseMatrix, pruneValue: number): SparseMatrix {\n  const is = [];\n  const js = [];\n  const ds = [];\n  for (let i = 0; i < sparseMatrix.i.length; i++) {\n    if (sparseMatrix.distance[i] > pruneValue) {\n      is.push(sparseMatrix.i[i]);\n      js.push(sparseMatrix.j[i]);\n      ds.push(sparseMatrix.distance[i]);\n    }\n  }\n  return {i: new Uint32Array(is), j: new Uint32Array(js), distance: new Float32Array(ds)};\n}\n\nexport function mclInflate(sparseMatrix: SparseMatrix, pow: number) {\n  const d = sparseMatrix.distance;\n  for (let i = 0; i < sparseMatrix.i.length; i++)\n    d[i] = Math.pow(d[i], pow);\n\n  return sparseMatrix;\n}\n\nexport function colwiseNormilize(\n  sparseMatrix: SparseMatrix, nRows: number, pruneValue: number, doPrune?: boolean\n): SparseMatrix {\n  if (doPrune)\n    sparseMatrix = prune(sparseMatrix, pruneValue);\n\n  const colSums = new Float32Array(nRows);\n  const d = sparseMatrix.distance;\n  const js = sparseMatrix.j;\n  for (let i = 0; i < sparseMatrix.i.length; i++)\n    colSums[js[i]] += d[i];\n\n  for (let i = 0; i < sparseMatrix.i.length; i++) {\n    const sum = colSums[js[i]];\n    if (sum !== 0)\n      d[i] /= sum;\n  }\n  return sparseMatrix;\n}\n\nexport function initMCLMatrix(sparseMatrix: SparseMatrix, nRows: number, pruneValue: number): SparseMatrix {\n  // here we get sparse matrix that is only a half of the matrix\n  // also, the matrix contains distances, need to convert those into similarities\n  // also, we need to add self loops\n  const is = new Uint32Array(sparseMatrix.i.length * 2 + nRows);\n  const js = new Uint32Array(sparseMatrix.j.length * 2 + nRows);\n  const ds = new Float32Array(sparseMatrix.distance.length * 2 + nRows);\n  for (let i = 0; i < nRows; i++) {\n    is[i] = i;\n    js[i] = i;\n    ds[i] = 1;\n  }\n  for (let i = 0; i < sparseMatrix.i.length; i++) {\n    const start = i * 2 + nRows;\n    is[start] = sparseMatrix.i[i];\n    js[start] = sparseMatrix.j[i];\n    ds[start] = 1 - sparseMatrix.distance[i];\n\n    is[start + 1] = sparseMatrix.j[i];\n    js[start + 1] = sparseMatrix.i[i];\n    ds[start + 1] = 1 - sparseMatrix.distance[i];\n  }\n\n  // normalize\n  colwiseNormilize({i: is, j: js, distance: ds}, nRows, pruneValue, false);\n\n  return {i: is, j: js, distance: ds};\n}\n\nexport async function runMarkovClustering(\n  sparseMatrix: SparseMatrix, nRows: number, inflate: number, maxIter: number, pruneValue: number\n) {\n  let matrix = initMCLMatrix(sparseMatrix, nRows, pruneValue);\n  for (let i = 0; i < maxIter; i++) {\n    matrix = await multSparseMatrix(matrix, nRows, pruneValue);\n    // console.time('inflate');\n    //@ts-ignore\n    matrix = colwiseNormilize(matrix, nRows, pruneValue, false);\n    matrix = mclInflate(matrix, inflate);\n\n    //@ts-ignore\n    matrix = colwiseNormilize(matrix, nRows, pruneValue, true);\n    console.log('MCL iteration', i);\n  }\n\n  return matrix;\n}\n"]}
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/ml/src/MCL/markov-cluster.js":
+/*!***********************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/ml/src/MCL/markov-cluster.js ***!
+  \***********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MCLSparseReducer: () => (/* binding */ MCLSparseReducer),
+/* harmony export */   defaultMCLOptions: () => (/* binding */ defaultMCLOptions)
+/* harmony export */ });
+/* harmony import */ var _clustering_steps__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./clustering-steps */ "./node_modules/@datagrok-libraries/ml/src/MCL/clustering-steps.js");
+/* harmony import */ var _webCola__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./webCola */ "./node_modules/@datagrok-libraries/ml/src/MCL/webCola.js");
+
+
+const defaultMCLOptions = {
+    expandFactor: 2,
+    maxIterations: 5,
+    inflateFactor: 2,
+    multFactor: 1,
+    pruneValue: 1e-17,
+};
+class MCLSparseReducer {
+    constructor(opts = {}) {
+        this._options = { ...defaultMCLOptions, ...opts };
+    }
+    async transform(sparseMatrix, nRows) {
+        // get the superClusters before the MCL
+        // this will be used for layouting
+        const superClusters = this.assignClusters(sparseMatrix, nRows);
+        this.correctClusters(superClusters.clusters);
+        // before beggining the mcl, we need to save the connections between original points,
+        // as MCL might mutate the matrix
+        const clusterConnectionMap = this.splitConnectionsIntoClusters(sparseMatrix, superClusters.clusters);
+        // perform the MCL
+        const mclMatrix = await (0,_clustering_steps__WEBPACK_IMPORTED_MODULE_0__.runMarkovClustering)(sparseMatrix, nRows, this._options.inflateFactor, this._options.maxIterations, this._options.pruneValue);
+        const { clusters } = this.assignClusters(mclMatrix, nRows);
+        this.correctClusters(clusters);
+        const embeddings = this.layout(superClusters.clusters, clusterConnectionMap, nRows, clusters);
+        return { clusters, embedX: embeddings.embedX, embedY: embeddings.embedY, is: sparseMatrix.i, js: sparseMatrix.j };
+    }
+    async transformWebGPU(sparseMatrix, nRows) {
+        // TODO: implement correct webGPU version
+        return this.transform(sparseMatrix, nRows);
+    }
+    // here as we operate on original sparse matrix, we know for sure that there are no duplicates or self loops
+    splitConnectionsIntoClusters(sparseMatrix, clusters) {
+        const clusterConnections = new Map();
+        for (let i = 0; i < clusters.length; i++) {
+            if (!clusterConnections.has(clusters[i]))
+                clusterConnections.set(clusters[i], { i: [], j: [], v: [] });
+        }
+        for (let i = 0; i < sparseMatrix.i.length; i++) {
+            const cluster = clusters[sparseMatrix.i[i]];
+            const cc = clusterConnections.get(cluster);
+            cc.i.push(sparseMatrix.i[i]);
+            cc.j.push(sparseMatrix.j[i]);
+            cc.v.push(1 - sparseMatrix.distance[i]);
+        }
+        return clusterConnections;
+    }
+    assignClusters(sparseMatrix, nRows) {
+        let clusterNum = 0;
+        const is = [];
+        const js = [];
+        // array containing for each point which cluster it belongs to
+        const clusters = new Array(nRows).fill(-1);
+        for (let it = 0; it < sparseMatrix.i.length; it++) {
+            const i = sparseMatrix.i[it];
+            const j = sparseMatrix.j[it];
+            if (i === j)
+                continue;
+            is.push(i);
+            js.push(j);
+            if (clusters[i] !== -1 && clusters[j] !== -1) {
+                if (clusters[i] !== clusters[j])
+                    this.mergeClusters(clusters, i, j);
+            }
+            else if (clusters[i] !== -1) {
+                clusters[j] = clusters[i];
+            }
+            else if (clusters[j] !== -1) {
+                clusters[i] = clusters[j];
+            }
+            else {
+                clusterNum++;
+                clusters[i] = clusterNum;
+                clusters[j] = clusterNum;
+            }
+        }
+        // final step for the clusters that are not connected to anything
+        for (let i = 0; i < clusters.length; i++) {
+            if (clusters[i] === -1) {
+                clusterNum++;
+                clusters[i] = clusterNum;
+            }
+        }
+        return { clusters, is: new Uint32Array(is), js: new Uint32Array(js) };
+    }
+    mergeClusters(clusters, i, j) {
+        const iCluster = clusters[i];
+        const jCluster = clusters[j];
+        for (let k = 0; k < clusters.length; k++) {
+            if (clusters[k] === jCluster)
+                clusters[k] = iCluster;
+        }
+    }
+    /** After assigning and merging, clusters will need reordering according to size */
+    correctClusters(clusters) {
+        const clusterSizeMap = {};
+        for (const cluster of clusters) {
+            if (!clusterSizeMap[cluster])
+                clusterSizeMap[cluster] = 0;
+            clusterSizeMap[cluster]++;
+        }
+        const sortedIndexes = Object.keys(clusterSizeMap).map(Number).sort((a, b) => clusterSizeMap[b] - clusterSizeMap[a]);
+        const clusterMap = {};
+        sortedIndexes.forEach((clusterIdx, i) => clusterMap[clusterIdx] = i + 1);
+        for (let i = 0; i < clusters.length; i++)
+            clusters[i] = clusterMap[clusters[i]];
+    }
+    /** notice that here, first argument is the superclusters and last is the subClusters
+     * the second argument is the original sparse matrix, and the third is the number of rows
+     */
+    layout(clusters, clusterConnectionMap, nRows, subCluster) {
+        const embedX = new Float32Array(nRows).fill(0);
+        const embedY = new Float32Array(nRows).fill(0);
+        const clusterMap = {};
+        clusters.forEach((cluster, i) => {
+            if (!clusterMap[cluster])
+                clusterMap[cluster] = [];
+            clusterMap[cluster].push(i);
+        });
+        // split sparse matrix connections into super-clusters, save only indexes
+        let clusterNum = 0;
+        const sortedClusterNames = Object.keys(clusterMap);
+        sortedClusterNames.sort((a, b) => clusterMap[b].length - clusterMap[a].length);
+        let perRow = 1;
+        const perRowMultiplier = 3;
+        let yOffset = 0;
+        const layoutSize = 5;
+        // cluster sizes could be different, but also very similar. first cluster size can be quite similar
+        // to the second one. if not accounted for, the layout will be very unbalanced, and first cluster will
+        // be very large
+        const perRowSizes = [1];
+        // if first two cluster sizes are very similar, first perrow should be 2
+        if (sortedClusterNames.length > 1) {
+            const clustSize1 = clusterMap[sortedClusterNames[0]].length;
+            const clustSize2 = clusterMap[sortedClusterNames[1]].length;
+            if (clustSize1 / clustSize2 < 2)
+                perRowSizes[0] = 2;
+            let curPerRowSize = perRowSizes[0];
+            let maxClustersInNextRow = curPerRowSize * perRowMultiplier;
+            let pointsInCurRow = curPerRowSize == 1 ? clustSize1 : clustSize1 + clustSize2;
+            let pointsAccum = 0;
+            let clustersAccum = 0;
+            for (let i = 2; i < sortedClusterNames.length; i++) {
+                pointsAccum += clusterMap[sortedClusterNames[i]].length;
+                clustersAccum++;
+                if (clustersAccum > maxClustersInNextRow || pointsAccum >= pointsInCurRow * 0.7 || i === sortedClusterNames.length - 1) {
+                    perRowSizes.push(i === sortedClusterNames.length - 1 ? maxClustersInNextRow : clustersAccum);
+                    curPerRowSize = clustersAccum;
+                    maxClustersInNextRow = curPerRowSize * perRowMultiplier;
+                    pointsInCurRow = Math.max(pointsAccum, pointsInCurRow);
+                    pointsAccum = 0;
+                    clustersAccum = 0;
+                }
+            }
+        }
+        perRow = perRowSizes[0];
+        let perRowIdx = 0;
+        for (const clusterName of sortedClusterNames) {
+            const cluster = clusterMap[clusterName];
+            const clusterConnections = clusterConnectionMap.get(Number(clusterName));
+            const embeddings = (0,_webCola__WEBPACK_IMPORTED_MODULE_1__.getWebColaLayot)(cluster, clusterConnections, subCluster);
+            if (clusterNum === perRow) {
+                clusterNum = 0;
+                yOffset += layoutSize / perRow;
+                perRowIdx++;
+                perRow = Math.min(Math.ceil(perRowSizes[perRowIdx]), 45);
+            }
+            //const clustersPerRow = Math.ceil(perRow / 1.5);
+            const offsetX = ((clusterNum) * layoutSize / perRow + layoutSize / perRow * (1 / 1.2 / 4));
+            // const offsetY = Math.floor(clusterNum / perRow) * 2;
+            for (let i = 0; i < embeddings.embedX.length; i++) {
+                embedX[cluster[i]] = embeddings.embedX[i] * layoutSize / perRow / 1.2 + offsetX;
+                embedY[cluster[i]] = embeddings.embedY[i] * layoutSize / perRow / 1.2 + yOffset;
+            }
+            clusterNum++;
+        }
+        return { embedX, embedY };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markov-cluster.js","sourceRoot":"","sources":["markov-cluster.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport {SparseMatrix} from '@datagrok-libraries/math';\nimport {MCLOptions} from './types';\nimport {runMarkovClustering} from './clustering-steps';\n\nimport {getWebColaLayot} from './webCola';\n\nexport const defaultMCLOptions: MCLOptions = {\n  expandFactor: 2,\n  maxIterations: 5,\n  inflateFactor: 2,\n  multFactor: 1,\n  pruneValue: 1e-17,\n};\n\nexport class MCLSparseReducer {\n    private _options: MCLOptions;\n\n    constructor(opts: Partial<MCLOptions> = {}) {\n      this._options = {...defaultMCLOptions, ...opts};\n    }\n\n    public async transform(sparseMatrix: SparseMatrix, nRows: number) {\n      // get the superClusters before the MCL\n      // this will be used for layouting\n      const superClusters = this.assignClusters(sparseMatrix, nRows);\n      this.correctClusters(superClusters.clusters);\n      // before beggining the mcl, we need to save the connections between original points,\n      // as MCL might mutate the matrix\n      const clusterConnectionMap = this.splitConnectionsIntoClusters(sparseMatrix, superClusters.clusters);\n      // perform the MCL\n      const mclMatrix = await runMarkovClustering(\n        sparseMatrix, nRows, this._options.inflateFactor, this._options.maxIterations, this._options.pruneValue);\n      const {clusters} = this.assignClusters(mclMatrix, nRows);\n      this.correctClusters(clusters);\n      const embeddings = this.layout(superClusters.clusters, clusterConnectionMap, nRows, clusters);\n      return {clusters, embedX: embeddings.embedX, embedY: embeddings.embedY, is: sparseMatrix.i, js: sparseMatrix.j};\n    }\n\n    public async transformWebGPU(sparseMatrix: SparseMatrix, nRows: number) {\n      // TODO: implement correct webGPU version\n      return this.transform(sparseMatrix, nRows);\n    }\n\n    // here as we operate on original sparse matrix, we know for sure that there are no duplicates or self loops\n    private splitConnectionsIntoClusters(sparseMatrix: SparseMatrix, clusters: number[]) {\n      const clusterConnections = new Map<number, {i: number[], j: number[], v: number[]}>();\n      for (let i = 0; i < clusters.length; i++) {\n        if (!clusterConnections.has(clusters[i]))\n          clusterConnections.set(clusters[i], {i: [], j: [], v: []});\n      }\n      for (let i = 0; i < sparseMatrix.i.length; i++) {\n        const cluster = clusters[sparseMatrix.i[i]];\n        const cc = clusterConnections.get(cluster)!;\n        cc.i.push(sparseMatrix.i[i]);\n        cc.j.push(sparseMatrix.j[i]);\n        cc.v.push(1 - sparseMatrix.distance[i]);\n      }\n      return clusterConnections;\n    }\n\n    private assignClusters(sparseMatrix: SparseMatrix, nRows: number) {\n      let clusterNum = 0;\n      const is: number[] = [];\n      const js: number[] = [];\n      // array containing for each point which cluster it belongs to\n      const clusters: number[] = new Array(nRows).fill(-1);\n      for (let it = 0; it < sparseMatrix.i.length; it++) {\n        const i = sparseMatrix.i[it];\n        const j = sparseMatrix.j[it];\n        if (i === j)\n          continue;\n        is.push(i);\n        js.push(j);\n        if (clusters[i] !== -1 && clusters[j] !== -1) {\n          if (clusters[i] !== clusters[j])\n            this.mergeClusters(clusters, i, j);\n        } else if (clusters[i] !== -1) {\n          clusters[j] = clusters[i];\n        } else if (clusters[j] !== -1) {\n          clusters[i] = clusters[j];\n        } else {\n          clusterNum++;\n          clusters[i] = clusterNum;\n          clusters[j] = clusterNum;\n        }\n      }\n\n      // final step for the clusters that are not connected to anything\n      for (let i=0; i < clusters.length; i++) {\n        if (clusters[i] === -1) {\n          clusterNum ++;\n          clusters[i] = clusterNum;\n        }\n      }\n      return {clusters, is: new Uint32Array(is), js: new Uint32Array(js)};\n    }\n\n    private mergeClusters(clusters: number[], i: number, j: number) {\n      const iCluster = clusters[i];\n      const jCluster = clusters[j];\n      for (let k = 0; k < clusters.length; k++) {\n        if (clusters[k] === jCluster)\n          clusters[k] = iCluster;\n      }\n    }\n\n    /** After assigning and merging, clusters will need reordering according to size */\n    private correctClusters(clusters: number[]) {\n      const clusterSizeMap: {[_: number]: number} = {};\n      for (const cluster of clusters) {\n        if (!clusterSizeMap[cluster])\n          clusterSizeMap[cluster] = 0;\n        clusterSizeMap[cluster]++;\n      }\n      const sortedIndexes =\n        Object.keys(clusterSizeMap).map(Number).sort((a, b) => clusterSizeMap[b] - clusterSizeMap[a]);\n      const clusterMap: {[_: number]: number} = {};\n      sortedIndexes.forEach((clusterIdx, i) => clusterMap[clusterIdx] = i + 1);\n      for (let i = 0; i < clusters.length; i++)\n        clusters[i] = clusterMap[clusters[i]];\n    }\n\n\n    /** notice that here, first argument is the superclusters and last is the subClusters\n     * the second argument is the original sparse matrix, and the third is the number of rows\n     */\n    private layout(clusters: number[], clusterConnectionMap: Map<number, {\n        i: number[];\n        j: number[];\n        v: number[];}>, nRows: number, subCluster: number[]) {\n      const embedX = new Float32Array(nRows).fill(0);\n      const embedY = new Float32Array(nRows).fill(0);\n      const clusterMap: {[_: number]: number[]} = {};\n      clusters.forEach((cluster, i) => {\n        if (!clusterMap[cluster])\n          clusterMap[cluster] = [];\n        clusterMap[cluster].push(i);\n      });\n\n      // split sparse matrix connections into super-clusters, save only indexes\n      let clusterNum = 0;\n      const sortedClusterNames = Object.keys(clusterMap);\n      sortedClusterNames.sort((a, b) => clusterMap[b as any].length - clusterMap[a as any].length);\n      let perRow = 1;\n      const perRowMultiplier = 3;\n\n      let yOffset = 0;\n      const layoutSize = 5;\n      // cluster sizes could be different, but also very similar. first cluster size can be quite similar\n      // to the second one. if not accounted for, the layout will be very unbalanced, and first cluster will\n      // be very large\n      const perRowSizes: number[] = [1];\n      // if first two cluster sizes are very similar, first perrow should be 2\n      if (sortedClusterNames.length > 1) {\n        const clustSize1 = clusterMap[sortedClusterNames[0] as any].length;\n        const clustSize2 = clusterMap[sortedClusterNames[1] as any].length;\n        if (clustSize1 / clustSize2 < 2)\n          perRowSizes[0] = 2;\n        let curPerRowSize = perRowSizes[0];\n        let maxClustersInNextRow = curPerRowSize * perRowMultiplier;\n        let pointsInCurRow = curPerRowSize == 1 ? clustSize1 : clustSize1 + clustSize2;\n        let pointsAccum = 0;\n        let clustersAccum = 0;\n        for (let i = 2; i < sortedClusterNames.length; i++) {\n          pointsAccum += clusterMap[sortedClusterNames[i] as any].length;\n          clustersAccum++;\n          if (clustersAccum > maxClustersInNextRow || pointsAccum >= pointsInCurRow * 0.7 || i === sortedClusterNames.length - 1) {\n            perRowSizes.push(i === sortedClusterNames.length - 1 ? maxClustersInNextRow : clustersAccum);\n            curPerRowSize = clustersAccum;\n            maxClustersInNextRow = curPerRowSize * perRowMultiplier;\n            pointsInCurRow = Math.max(pointsAccum, pointsInCurRow);\n            pointsAccum = 0;\n            clustersAccum = 0;\n          }\n        }\n      }\n      perRow = perRowSizes[0];\n      let perRowIdx = 0;\n\n      for (const clusterName of sortedClusterNames) {\n        const cluster = clusterMap[clusterName as any]!;\n        const clusterConnections = clusterConnectionMap.get(Number(clusterName))!;\n        const embeddings = getWebColaLayot(cluster, clusterConnections, subCluster);\n        if (clusterNum === perRow) {\n          clusterNum = 0;\n          yOffset += layoutSize / perRow;\n          perRowIdx++;\n          perRow = Math.min(Math.ceil(perRowSizes[perRowIdx]), 45);\n        }\n        //const clustersPerRow = Math.ceil(perRow / 1.5);\n        const offsetX = ((clusterNum) * layoutSize / perRow + layoutSize / perRow * (1 / 1.2 / 4));\n        // const offsetY = Math.floor(clusterNum / perRow) * 2;\n\n        for (let i = 0; i < embeddings.embedX.length; i++) {\n          embedX[cluster[i]] = embeddings.embedX[i] * layoutSize / perRow / 1.2 + offsetX;\n          embedY[cluster[i]] = embeddings.embedY[i] * layoutSize / perRow / 1.2 + yOffset;\n        }\n        clusterNum++;\n      }\n      return {embedX, embedY};\n    }\n}\n\n\n"]}
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/ml/src/MCL/mcl-sparse-matrix-mult.js":
+/*!*******************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/ml/src/MCL/mcl-sparse-matrix-mult.js ***!
+  \*******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   multSparseMatrix: () => (/* binding */ multSparseMatrix)
+/* harmony export */ });
+// simple semaphore
+let semaphore = Promise.resolve();
+const lock = async () => {
+    await semaphore;
+    let release = () => { };
+    const promise = new Promise((resolve) => {
+        release = resolve;
+    });
+    semaphore = promise;
+    return release;
+};
+/** Multiplies sparse matrix by itself. note that it expects that sparse matrix is full
+ * (i.e. not only the upper right corner) and it has self loops if any */
+async function multSparseMatrix(sparseMatrix, nRows, pruneValue) {
+    const workersNum = Math.min(Math.min(Math.max(navigator.hardwareConcurrency - 2, 1), nRows), 10);
+    // number of horizontal strips that we will divide the matrix into
+    // we divide the matrix into horizontal strips, because its faster for indexing and better for cache
+    const numOfHorizontalStrinps = workersNum * 5;
+    const indexStarts = new Uint32Array(numOfHorizontalStrinps);
+    const indexEnds = new Uint32Array(numOfHorizontalStrinps);
+    const blockHeight = nRows / numOfHorizontalStrinps;
+    for (let i = 0; i < numOfHorizontalStrinps; i++) {
+        indexStarts[i] = Math.floor(i * blockHeight);
+        indexEnds[i] = i === numOfHorizontalStrinps - 1 ? nRows : Math.floor((i + 1) * blockHeight);
+    }
+    const workers = new Array(workersNum).fill(0)
+        .map(() => new Worker(new URL(/* worker import */ __webpack_require__.p + __webpack_require__.u("node_modules_datagrok-libraries_ml_src_MCL_mcl-sparse-matrix-mult-worker_js"), __webpack_require__.b)));
+    const availableIndexes = new Set();
+    for (let i = 0; i < numOfHorizontalStrinps; i++)
+        availableIndexes.add(i);
+    const initPromises = workers.map((worker) => {
+        return new Promise((resolve) => {
+            worker.postMessage({
+                is: sparseMatrix.i,
+                js: sparseMatrix.j,
+                ds: sparseMatrix.distance,
+                nRows,
+                pruneValue
+            });
+            worker.onmessage = () => {
+                resolve();
+            };
+        });
+    });
+    await Promise.all(initPromises);
+    const res = [];
+    const takeChunk = async (workerIdx) => {
+        const release = await lock();
+        const index = availableIndexes.values().next().value;
+        if (index == null) {
+            release();
+            return;
+        }
+        availableIndexes.delete(index);
+        release();
+        await new Promise((resolve) => {
+            workers[workerIdx].postMessage({
+                blockStart: indexStarts[index],
+                blockEnd: indexEnds[index],
+                workerIdx
+            });
+            workers[workerIdx].onmessage = (e) => {
+                res.push(e.data);
+                resolve();
+            };
+        });
+        await takeChunk(workerIdx);
+    };
+    const promises = workers.map((_worker, i) => {
+        return takeChunk(i);
+    });
+    await Promise.all(promises);
+    workers.forEach((worker) => worker.terminate());
+    let totLen = 0;
+    for (const r of res)
+        totLen += r.i.length;
+    const i = new Uint32Array(totLen);
+    const j = new Uint32Array(totLen);
+    const d = new Float32Array(totLen);
+    let offset = 0;
+    for (const r of res) {
+        i.set(r.i, offset);
+        j.set(r.j, offset);
+        d.set(r.distance, offset);
+        offset += r.i.length;
+    }
+    // don't forget to get the updated values for the diagonal, their rows need to be basically squared and summed
+    // also, the diagonal values are not pruned
+    return { i, j, distance: d };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcl-sparse-matrix-mult.js","sourceRoot":"","sources":["mcl-sparse-matrix-mult.ts"],"names":[],"mappings":"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","sourcesContent":["import {SparseMatrix} from '@datagrok-libraries/math';\n\n// simple semaphore\nlet semaphore = Promise.resolve();\n\nconst lock = async () => {\n  await semaphore;\n  let release: () => void = () => {};\n  const promise = new Promise<void>((resolve) => {\n    release = resolve;\n  });\n  semaphore = promise;\n  return release;\n};\n\n\n/** Multiplies sparse matrix by itself. note that it expects that sparse matrix is full\n * (i.e. not only the upper right corner) and it has self loops if any */\nexport async function multSparseMatrix(\n  sparseMatrix: SparseMatrix, nRows: number, pruneValue: number\n): Promise<SparseMatrix> {\n  const workersNum = Math.min(Math.min(Math.max(navigator.hardwareConcurrency - 2, 1), nRows), 10);\n\n  // number of horizontal strips that we will divide the matrix into\n  // we divide the matrix into horizontal strips, because its faster for indexing and better for cache\n  const numOfHorizontalStrinps = workersNum * 5;\n\n  const indexStarts = new Uint32Array(numOfHorizontalStrinps);\n  const indexEnds = new Uint32Array(numOfHorizontalStrinps);\n\n  const blockHeight = nRows / numOfHorizontalStrinps;\n  for (let i = 0; i < numOfHorizontalStrinps; i++) {\n    indexStarts[i] = Math.floor(i * blockHeight);\n    indexEnds[i] = i === numOfHorizontalStrinps - 1 ? nRows : Math.floor((i + 1) * blockHeight);\n  }\n\n\n  const workers: Worker[] = new Array(workersNum).fill(0)\n    .map(() => new Worker(new URL('./mcl-sparse-matrix-mult-worker', import.meta.url)));\n\n\n  const availableIndexes = new Set<number>();\n  for (let i = 0; i < numOfHorizontalStrinps; i++)\n    availableIndexes.add(i);\n\n  const initPromises = workers.map((worker) => {\n    return new Promise<void>((resolve) => {\n      worker.postMessage({\n        is: sparseMatrix.i,\n        js: sparseMatrix.j,\n        ds: sparseMatrix.distance,\n        nRows,\n        pruneValue\n      });\n\n      worker.onmessage = () => {\n        resolve();\n      };\n    });\n  });\n  await Promise.all(initPromises);\n\n  const res: SparseMatrix[] = [];\n\n  const takeChunk = async (workerIdx: number) => {\n    const release = await lock();\n    const index = availableIndexes.values().next().value;\n    if (index == null) {\n      release();\n      return;\n    }\n    availableIndexes.delete(index);\n    release();\n    await new Promise<void>((resolve) => {\n      workers[workerIdx].postMessage({\n        blockStart: indexStarts[index],\n        blockEnd: indexEnds[index],\n        workerIdx\n      });\n\n      workers[workerIdx].onmessage = (e) => {\n        res.push(e.data);\n        resolve();\n      };\n    });\n    await takeChunk(workerIdx);\n  };\n\n\n  const promises = workers.map((_worker, i) => {\n    return takeChunk(i);\n  });\n  await Promise.all(promises);\n  workers.forEach((worker) => worker.terminate());\n\n\n  let totLen = 0;\n  for (const r of res)\n    totLen += r.i.length;\n\n  const i = new Uint32Array(totLen);\n  const j = new Uint32Array(totLen);\n  const d = new Float32Array(totLen);\n  let offset = 0;\n  for (const r of res) {\n    i.set(r.i, offset);\n    j.set(r.j, offset);\n    d.set(r.distance, offset);\n    offset += r.i.length;\n  }\n\n  // don't forget to get the updated values for the diagonal, their rows need to be basically squared and summed\n  // also, the diagonal values are not pruned\n\n  return {i, j, distance: d};\n}\n"]}
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/ml/src/MCL/mcl-worker.js":
+/*!*******************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/ml/src/MCL/mcl-worker.js ***!
+  \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _datagrok_libraries_math_src_webGPU_sparse_matrix_webGPU_sparse_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @datagrok-libraries/math/src/webGPU/sparse-matrix/webGPU-sparse-matrix */ "./node_modules/@datagrok-libraries/math/src/webGPU/sparse-matrix/webGPU-sparse-matrix.js");
+/* harmony import */ var _distance_matrix_sparse_matrix_service__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../distance-matrix/sparse-matrix-service */ "./node_modules/@datagrok-libraries/ml/src/distance-matrix/sparse-matrix-service.js");
+/* harmony import */ var _markov_cluster__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./markov-cluster */ "./node_modules/@datagrok-libraries/ml/src/MCL/markov-cluster.js");
+
+
+
+onmessage = async (event) => {
+    const { data, threshold, weights, aggregationMethod, distanceFnArgs, distanceFns, maxIterations, useWebGPU, inflate } = event.data;
+    console.time('sparse matrix');
+    let sparse = null;
+    if (useWebGPU) {
+        try {
+            sparse = await (0,_datagrok_libraries_math_src_webGPU_sparse_matrix_webGPU_sparse_matrix__WEBPACK_IMPORTED_MODULE_0__.multiColWebGPUSparseMatrix)(data, threshold / 100, distanceFns, aggregationMethod, weights, distanceFnArgs);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    if (!sparse) { // falsback to CPU
+        if (useWebGPU)
+            console.error('WEBGPU sparse matrix calculation failed, falling back to CPU implementation');
+        sparse = await new _distance_matrix_sparse_matrix_service__WEBPACK_IMPORTED_MODULE_1__.SparseMatrixService()
+            .calcMultiColumn(data, distanceFns, threshold / 100, distanceFnArgs, weights, aggregationMethod);
+    }
+    const MAX_MCL_CONNECTIONS = 1000000;
+    if (sparse.i.length > MAX_MCL_CONNECTIONS)
+        sparse = _distance_matrix_sparse_matrix_service__WEBPACK_IMPORTED_MODULE_1__.SparseMatrixService.pruneSparseMatrix(sparse, MAX_MCL_CONNECTIONS);
+    console.timeEnd('sparse matrix');
+    //const res = await new MCLSparseReducer({maxIterations: maxIterations ?? 5}).transform(sparse, data[0].length);
+    const reducer = new _markov_cluster__WEBPACK_IMPORTED_MODULE_2__.MCLSparseReducer({ maxIterations: maxIterations ?? 5, inflateFactor: inflate ?? 2 });
+    console.time('MCL');
+    let res = null;
+    if (useWebGPU) {
+        try {
+            res = await reducer.transformWebGPU(sparse, data[0].length);
+        }
+        catch (e) {
+            console.error('webGPU MCL failed, falling back to CPU implementation');
+            console.error(e);
+        }
+    }
+    if (!res)
+        res = await reducer.transform(sparse, data[0].length);
+    console.timeEnd('MCL');
+    postMessage({ res });
+};
+//# sourceMappingURL=data:application/json;base64,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
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/ml/src/MCL/webCola.js":
+/*!****************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/ml/src/MCL/webCola.js ***!
+  \****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getWebColaLayot: () => (/* binding */ getWebColaLayot)
+/* harmony export */ });
+/* harmony import */ var graphology__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! graphology */ "./node_modules/graphology/dist/graphology.umd.min.js");
+/* harmony import */ var graphology__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(graphology__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var graphology_layout_forceatlas2__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! graphology-layout-forceatlas2 */ "./node_modules/graphology-layout-forceatlas2/index.js");
+/* harmony import */ var graphology_layout_forceatlas2__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(graphology_layout_forceatlas2__WEBPACK_IMPORTED_MODULE_1__);
+/* eslint-disable max-len */
+
+
+// note: subCluster is of size nRows and contains for each point which subcluster it belongs to
+// note: cluster is of size of this concrete supercluster, and contains the indexes of the points in that supercluster
+function getWebColaLayot(cluster, clusterConnections, _subCluster) {
+    const graph = new (graphology__WEBPACK_IMPORTED_MODULE_0___default())();
+    for (let i = 0; i < cluster.length; i++)
+        graph.addNode(cluster[i], { x: Math.random() * 20000, y: Math.random() * 20000 });
+    for (let it = 0; it < clusterConnections.i.length; it++) {
+        const i = clusterConnections.i[it];
+        const j = clusterConnections.j[it];
+        const v = clusterConnections.v[it];
+        if (i === j || v <= 0)
+            continue;
+        const weight = _subCluster[i] === _subCluster[j] ? 2 : 1;
+        graph.addEdge(i, j, { weight: v * weight });
+    }
+    const settings = {
+        iterations: 100,
+        // edgeWeightInfluence: 1, // Influence of edge weights on the layout
+        // scalingRatio: 1, // Scaling ratio to account for node sizes
+        // //barnesHutOptimize: true,
+        // //barnesHutTheta: 0.5,
+        // adjustSizes: true,
+        // weighted: true,
+        // strongGravityMode: true,
+        getEdgeWeight: 'weight',
+        settings: { ...graphology_layout_forceatlas2__WEBPACK_IMPORTED_MODULE_1___default().inferSettings(graph), weighted: true, edgeWeightInfluence: 1 }
+    };
+    graphology_layout_forceatlas2__WEBPACK_IMPORTED_MODULE_1___default().assign(graph, settings);
+    const embedX1 = new Float32Array(cluster.length);
+    const embedY1 = new Float32Array(cluster.length);
+    for (let i = 0; i < cluster.length; i++) {
+        const node = graph.getNodeAttributes(cluster[i]);
+        embedX1[i] = node.x;
+        embedY1[i] = node.y;
+    }
+    let minX = embedX1[0];
+    let minY = embedY1[0];
+    let maxX = embedX1[0];
+    let maxY = embedY1[0];
+    for (let i = 1; i < cluster.length; i++) {
+        minX = Math.min(minX, embedX1[i]);
+        minY = Math.min(minY, embedY1[i]);
+        maxX = Math.max(maxX, embedX1[i]);
+        maxY = Math.max(maxY, embedY1[i]);
+    }
+    let scaleX = maxX - minX;
+    let scaleY = maxY - minY;
+    if (scaleX === 0)
+        scaleX = 1;
+    if (scaleY === 0)
+        scaleY = 1;
+    for (let i = 0; i < cluster.length; i++) {
+        embedX1[i] = (embedX1[i] - minX) / scaleX;
+        embedY1[i] = (embedY1[i] - minY) / scaleY;
+    }
+    return { embedX: embedX1, embedY: embedY1 };
+}
+//# sourceMappingURL=data:application/json;base64,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
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/ml/src/distance-matrix/types.js":
+/*!**************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/ml/src/distance-matrix/types.js ***!
+  \**************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DistanceAggregationMethods: () => (/* binding */ DistanceAggregationMethods)
+/* harmony export */ });
+var DistanceAggregationMethods;
+(function (DistanceAggregationMethods) {
+    DistanceAggregationMethods["EUCLIDEAN"] = "EUCLIDEAN";
+    DistanceAggregationMethods["MANHATTAN"] = "MANHATTAN";
+})(DistanceAggregationMethods || (DistanceAggregationMethods = {}));
+;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSwwQkFHVDtBQUhILFdBQVksMEJBQTBCO0lBQ2xDLHFEQUF1QixDQUFBO0lBQ3ZCLHFEQUF1QixDQUFBO0FBQ3pCLENBQUMsRUFIUywwQkFBMEIsS0FBMUIsMEJBQTBCLFFBR25DO0FBQUEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIERpc3RhbmNlQWdncmVnYXRpb25NZXRob2RzIHtcbiAgICBFVUNMSURFQU4gPSAnRVVDTElERUFOJyxcbiAgICBNQU5IQVRUQU4gPSAnTUFOSEFUVEFOJyxcbiAgfTtcblxuZXhwb3J0IHR5cGUgRGlzdGFuY2VBZ2dyZWdhdGlvbk1ldGhvZCA9IGtleW9mIHR5cGVvZiBEaXN0YW5jZUFnZ3JlZ2F0aW9uTWV0aG9kcztcbiJdfQ==
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/ml/src/distance-matrix/utils.js":
+/*!**************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/ml/src/distance-matrix/utils.js ***!
+  \**************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getAggregationFunction: () => (/* binding */ getAggregationFunction),
+/* harmony export */   insertLarger: () => (/* binding */ insertLarger),
+/* harmony export */   insertSmaller: () => (/* binding */ insertSmaller),
+/* harmony export */   isNil: () => (/* binding */ isNil)
+/* harmony export */ });
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./types */ "./node_modules/@datagrok-libraries/ml/src/distance-matrix/types.js");
+
+const isNil = (x) => x === null || x === undefined;
+function insertSmaller(distancesAr, indexes, num, index) {
+    if (num > distancesAr[distancesAr.length - 1])
+        return;
+    const newPosition = distancesAr.findIndex((v) => num < v);
+    distancesAr.pop();
+    distancesAr.splice(newPosition, 0, num);
+    indexes.pop();
+    indexes.splice(newPosition, 0, index);
+}
+function insertLarger(distancesAr, indexes, num, index) {
+    if (num < distancesAr[distancesAr.length - 1])
+        return;
+    const newPosition = distancesAr.findIndex((v) => num > v);
+    distancesAr.pop();
+    distancesAr.splice(newPosition, 0, num);
+    indexes.pop();
+    indexes.splice(newPosition, 0, index);
+}
+function getAggregationFunction(aggregationMethod, weights) {
+    switch (aggregationMethod) {
+        case _types__WEBPACK_IMPORTED_MODULE_0__.DistanceAggregationMethods.MANHATTAN:
+            return (vs) => vs.reduce((acc, val, idx) => acc + val * weights[idx], 0);
+        default:
+            return (vs) => {
+                // euclidean
+                const sum = vs.reduce((acc, val, idx) => acc + (val * weights[idx]) ** 2, 0);
+                return Math.sqrt(sum);
+            };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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
+
+/***/ }),
+
+/***/ "./node_modules/graphology-layout-forceatlas2/defaults.js":
+/*!****************************************************************!*\
+  !*** ./node_modules/graphology-layout-forceatlas2/defaults.js ***!
+  \****************************************************************/
+/***/ ((module) => {
+
+/**
+ * Graphology ForceAtlas2 Layout Default Settings
+ * ===============================================
+ */
+module.exports = {
+  linLogMode: false,
+  outboundAttractionDistribution: false,
+  adjustSizes: false,
+  edgeWeightInfluence: 1,
+  scalingRatio: 1,
+  strongGravityMode: false,
+  gravity: 1,
+  slowDown: 1,
+  barnesHutOptimize: false,
+  barnesHutTheta: 0.5
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/graphology-layout-forceatlas2/helpers.js":
+/*!***************************************************************!*\
+  !*** ./node_modules/graphology-layout-forceatlas2/helpers.js ***!
+  \***************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+/**
+ * Graphology ForceAtlas2 Helpers
+ * ===============================
+ *
+ * Miscellaneous helper functions.
+ */
+
+/**
+ * Constants.
+ */
+var PPN = 10;
+var PPE = 3;
+
+/**
+ * Very simple Object.assign-like function.
+ *
+ * @param  {object} target       - First object.
+ * @param  {object} [...objects] - Objects to merge.
+ * @return {object}
+ */
+exports.assign = function (target) {
+  target = target || {};
+
+  var objects = Array.prototype.slice.call(arguments).slice(1),
+    i,
+    k,
+    l;
+
+  for (i = 0, l = objects.length; i < l; i++) {
+    if (!objects[i]) continue;
+
+    for (k in objects[i]) target[k] = objects[i][k];
+  }
+
+  return target;
+};
+
+/**
+ * Function used to validate the given settings.
+ *
+ * @param  {object}      settings - Settings to validate.
+ * @return {object|null}
+ */
+exports.validateSettings = function (settings) {
+  if ('linLogMode' in settings && typeof settings.linLogMode !== 'boolean')
+    return {message: 'the `linLogMode` setting should be a boolean.'};
+
+  if (
+    'outboundAttractionDistribution' in settings &&
+    typeof settings.outboundAttractionDistribution !== 'boolean'
+  )
+    return {
+      message:
+        'the `outboundAttractionDistribution` setting should be a boolean.'
+    };
+
+  if ('adjustSizes' in settings && typeof settings.adjustSizes !== 'boolean')
+    return {message: 'the `adjustSizes` setting should be a boolean.'};
+
+  if (
+    'edgeWeightInfluence' in settings &&
+    typeof settings.edgeWeightInfluence !== 'number'
+  )
+    return {
+      message: 'the `edgeWeightInfluence` setting should be a number.'
+    };
+
+  if (
+    'scalingRatio' in settings &&
+    !(typeof settings.scalingRatio === 'number' && settings.scalingRatio >= 0)
+  )
+    return {message: 'the `scalingRatio` setting should be a number >= 0.'};
+
+  if (
+    'strongGravityMode' in settings &&
+    typeof settings.strongGravityMode !== 'boolean'
+  )
+    return {message: 'the `strongGravityMode` setting should be a boolean.'};
+
+  if (
+    'gravity' in settings &&
+    !(typeof settings.gravity === 'number' && settings.gravity >= 0)
+  )
+    return {message: 'the `gravity` setting should be a number >= 0.'};
+
+  if (
+    'slowDown' in settings &&
+    !(typeof settings.slowDown === 'number' || settings.slowDown >= 0)
+  )
+    return {message: 'the `slowDown` setting should be a number >= 0.'};
+
+  if (
+    'barnesHutOptimize' in settings &&
+    typeof settings.barnesHutOptimize !== 'boolean'
+  )
+    return {message: 'the `barnesHutOptimize` setting should be a boolean.'};
+
+  if (
+    'barnesHutTheta' in settings &&
+    !(
+      typeof settings.barnesHutTheta === 'number' &&
+      settings.barnesHutTheta >= 0
+    )
+  )
+    return {message: 'the `barnesHutTheta` setting should be a number >= 0.'};
+
+  return null;
+};
+
+/**
+ * Function generating a flat matrix for both nodes & edges of the given graph.
+ *
+ * @param  {Graph}    graph         - Target graph.
+ * @param  {function} getEdgeWeight - Edge weight getter function.
+ * @return {object}                 - Both matrices.
+ */
+exports.graphToByteArrays = function (graph, getEdgeWeight) {
+  var order = graph.order;
+  var size = graph.size;
+  var index = {};
+  var j;
+
+  // NOTE: float32 could lead to issues if edge array needs to index large
+  // number of nodes.
+  var NodeMatrix = new Float32Array(order * PPN);
+  var EdgeMatrix = new Float32Array(size * PPE);
+
+  // Iterate through nodes
+  j = 0;
+  graph.forEachNode(function (node, attr) {
+    // Node index
+    index[node] = j;
+
+    // Populating byte array
+    NodeMatrix[j] = attr.x;
+    NodeMatrix[j + 1] = attr.y;
+    NodeMatrix[j + 2] = 0; // dx
+    NodeMatrix[j + 3] = 0; // dy
+    NodeMatrix[j + 4] = 0; // old_dx
+    NodeMatrix[j + 5] = 0; // old_dy
+    NodeMatrix[j + 6] = 1; // mass
+    NodeMatrix[j + 7] = 1; // convergence
+    NodeMatrix[j + 8] = attr.size || 1;
+    NodeMatrix[j + 9] = attr.fixed ? 1 : 0;
+    j += PPN;
+  });
+
+  // Iterate through edges
+  j = 0;
+  graph.forEachEdge(function (edge, attr, source, target, sa, ta, u) {
+    var sj = index[source];
+    var tj = index[target];
+
+    var weight = getEdgeWeight(edge, attr, source, target, sa, ta, u);
+
+    // Incrementing mass to be a node's weighted degree
+    NodeMatrix[sj + 6] += weight;
+    NodeMatrix[tj + 6] += weight;
+
+    // Populating byte array
+    EdgeMatrix[j] = sj;
+    EdgeMatrix[j + 1] = tj;
+    EdgeMatrix[j + 2] = weight;
+    j += PPE;
+  });
+
+  return {
+    nodes: NodeMatrix,
+    edges: EdgeMatrix
+  };
+};
+
+/**
+ * Function applying the layout back to the graph.
+ *
+ * @param {Graph}         graph         - Target graph.
+ * @param {Float32Array}  NodeMatrix    - Node matrix.
+ * @param {function|null} outputReducer - A node reducer.
+ */
+exports.assignLayoutChanges = function (graph, NodeMatrix, outputReducer) {
+  var i = 0;
+
+  graph.updateEachNodeAttributes(function (node, attr) {
+    attr.x = NodeMatrix[i];
+    attr.y = NodeMatrix[i + 1];
+
+    i += PPN;
+
+    return outputReducer ? outputReducer(node, attr) : attr;
+  });
+};
+
+/**
+ * Function reading the positions (only) from the graph, to write them in the matrix.
+ *
+ * @param {Graph}        graph      - Target graph.
+ * @param {Float32Array} NodeMatrix - Node matrix.
+ */
+exports.readGraphPositions = function (graph, NodeMatrix) {
+  var i = 0;
+
+  graph.forEachNode(function (node, attr) {
+    NodeMatrix[i] = attr.x;
+    NodeMatrix[i + 1] = attr.y;
+
+    i += PPN;
+  });
+};
+
+/**
+ * Function collecting the layout positions.
+ *
+ * @param  {Graph}         graph         - Target graph.
+ * @param  {Float32Array}  NodeMatrix    - Node matrix.
+ * @param  {function|null} outputReducer - A nodes reducer.
+ * @return {object}                      - Map to node positions.
+ */
+exports.collectLayoutChanges = function (graph, NodeMatrix, outputReducer) {
+  var nodes = graph.nodes(),
+    positions = {};
+
+  for (var i = 0, j = 0, l = NodeMatrix.length; i < l; i += PPN) {
+    if (outputReducer) {
+      var newAttr = Object.assign({}, graph.getNodeAttributes(nodes[j]));
+      newAttr.x = NodeMatrix[i];
+      newAttr.y = NodeMatrix[i + 1];
+      newAttr = outputReducer(nodes[j], newAttr);
+      positions[nodes[j]] = {
+        x: newAttr.x,
+        y: newAttr.y
+      };
+    } else {
+      positions[nodes[j]] = {
+        x: NodeMatrix[i],
+        y: NodeMatrix[i + 1]
+      };
+    }
+
+    j++;
+  }
+
+  return positions;
+};
+
+/**
+ * Function returning a web worker from the given function.
+ *
+ * @param  {function}  fn - Function for the worker.
+ * @return {DOMString}
+ */
+exports.createWorker = function createWorker(fn) {
+  var xURL = window.URL || window.webkitURL;
+  var code = fn.toString();
+  var objectUrl = xURL.createObjectURL(
+    new Blob(['(' + code + ').call(this);'], {type: 'text/javascript'})
+  );
+  var worker = new Worker(objectUrl);
+  xURL.revokeObjectURL(objectUrl);
+
+  return worker;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/graphology-layout-forceatlas2/index.js":
+/*!*************************************************************!*\
+  !*** ./node_modules/graphology-layout-forceatlas2/index.js ***!
+  \*************************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/**
+ * Graphology ForceAtlas2 Layout
+ * ==============================
+ *
+ * Library endpoint.
+ */
+var isGraph = __webpack_require__(/*! graphology-utils/is-graph */ "./node_modules/graphology-utils/is-graph.js");
+var createEdgeWeightGetter =
+  (__webpack_require__(/*! graphology-utils/getters */ "./node_modules/graphology-utils/getters.js").createEdgeWeightGetter);
+var iterate = __webpack_require__(/*! ./iterate.js */ "./node_modules/graphology-layout-forceatlas2/iterate.js");
+var helpers = __webpack_require__(/*! ./helpers.js */ "./node_modules/graphology-layout-forceatlas2/helpers.js");
+
+var DEFAULT_SETTINGS = __webpack_require__(/*! ./defaults.js */ "./node_modules/graphology-layout-forceatlas2/defaults.js");
+
+/**
+ * Asbtract function used to run a certain number of iterations.
+ *
+ * @param  {boolean}       assign          - Whether to assign positions.
+ * @param  {Graph}         graph           - Target graph.
+ * @param  {object|number} params          - If number, params.iterations, else:
+ * @param  {function}        getWeight     - Edge weight getter function.
+ * @param  {number}          iterations    - Number of iterations.
+ * @param  {function|null}   outputReducer - A node reducer
+ * @param  {object}          [settings]    - Settings.
+ * @return {object|undefined}
+ */
+function abstractSynchronousLayout(assign, graph, params) {
+  if (!isGraph(graph))
+    throw new Error(
+      'graphology-layout-forceatlas2: the given graph is not a valid graphology instance.'
+    );
+
+  if (typeof params === 'number') params = {iterations: params};
+
+  var iterations = params.iterations;
+
+  if (typeof iterations !== 'number')
+    throw new Error(
+      'graphology-layout-forceatlas2: invalid number of iterations.'
+    );
+
+  if (iterations <= 0)
+    throw new Error(
+      'graphology-layout-forceatlas2: you should provide a positive number of iterations.'
+    );
+
+  var getEdgeWeight = createEdgeWeightGetter(
+    'getEdgeWeight' in params ? params.getEdgeWeight : 'weight'
+  ).fromEntry;
+
+  var outputReducer =
+    typeof params.outputReducer === 'function' ? params.outputReducer : null;
+
+  // Validating settings
+  var settings = helpers.assign({}, DEFAULT_SETTINGS, params.settings);
+  var validationError = helpers.validateSettings(settings);
+
+  if (validationError)
+    throw new Error(
+      'graphology-layout-forceatlas2: ' + validationError.message
+    );
+
+  // Building matrices
+  var matrices = helpers.graphToByteArrays(graph, getEdgeWeight);
+
+  var i;
+
+  // Iterating
+  for (i = 0; i < iterations; i++)
+    iterate(settings, matrices.nodes, matrices.edges);
+
+  // Applying
+  if (assign) {
+    helpers.assignLayoutChanges(graph, matrices.nodes, outputReducer);
+    return;
+  }
+
+  return helpers.collectLayoutChanges(graph, matrices.nodes);
+}
+
+/**
+ * Function returning sane layout settings for the given graph.
+ *
+ * @param  {Graph|number} graph - Target graph or graph order.
+ * @return {object}
+ */
+function inferSettings(graph) {
+  var order = typeof graph === 'number' ? graph : graph.order;
+
+  return {
+    barnesHutOptimize: order > 2000,
+    strongGravityMode: true,
+    gravity: 0.05,
+    scalingRatio: 10,
+    slowDown: 1 + Math.log(order)
+  };
+}
+
+/**
+ * Exporting.
+ */
+var synchronousLayout = abstractSynchronousLayout.bind(null, false);
+synchronousLayout.assign = abstractSynchronousLayout.bind(null, true);
+synchronousLayout.inferSettings = inferSettings;
+
+module.exports = synchronousLayout;
+
+
+/***/ }),
+
+/***/ "./node_modules/graphology-layout-forceatlas2/iterate.js":
+/*!***************************************************************!*\
+  !*** ./node_modules/graphology-layout-forceatlas2/iterate.js ***!
+  \***************************************************************/
+/***/ ((module) => {
+
+/* eslint no-constant-condition: 0 */
+/**
+ * Graphology ForceAtlas2 Iteration
+ * =================================
+ *
+ * Function used to perform a single iteration of the algorithm.
+ */
+
+/**
+ * Matrices properties accessors.
+ */
+var NODE_X = 0;
+var NODE_Y = 1;
+var NODE_DX = 2;
+var NODE_DY = 3;
+var NODE_OLD_DX = 4;
+var NODE_OLD_DY = 5;
+var NODE_MASS = 6;
+var NODE_CONVERGENCE = 7;
+var NODE_SIZE = 8;
+var NODE_FIXED = 9;
+
+var EDGE_SOURCE = 0;
+var EDGE_TARGET = 1;
+var EDGE_WEIGHT = 2;
+
+var REGION_NODE = 0;
+var REGION_CENTER_X = 1;
+var REGION_CENTER_Y = 2;
+var REGION_SIZE = 3;
+var REGION_NEXT_SIBLING = 4;
+var REGION_FIRST_CHILD = 5;
+var REGION_MASS = 6;
+var REGION_MASS_CENTER_X = 7;
+var REGION_MASS_CENTER_Y = 8;
+
+var SUBDIVISION_ATTEMPTS = 3;
+
+/**
+ * Constants.
+ */
+var PPN = 10;
+var PPE = 3;
+var PPR = 9;
+
+var MAX_FORCE = 10;
+
+/**
+ * Function used to perform a single interation of the algorithm.
+ *
+ * @param  {object}       options    - Layout options.
+ * @param  {Float32Array} NodeMatrix - Node data.
+ * @param  {Float32Array} EdgeMatrix - Edge data.
+ * @return {object}                  - Some metadata.
+ */
+module.exports = function iterate(options, NodeMatrix, EdgeMatrix) {
+  // Initializing variables
+  var l, r, n, n1, n2, rn, e, w, g, s;
+
+  var order = NodeMatrix.length,
+    size = EdgeMatrix.length;
+
+  var adjustSizes = options.adjustSizes;
+
+  var thetaSquared = options.barnesHutTheta * options.barnesHutTheta;
+
+  var outboundAttCompensation, coefficient, xDist, yDist, ewc, distance, factor;
+
+  var RegionMatrix = [];
+
+  // 1) Initializing layout data
+  //-----------------------------
+
+  // Resetting positions & computing max values
+  for (n = 0; n < order; n += PPN) {
+    NodeMatrix[n + NODE_OLD_DX] = NodeMatrix[n + NODE_DX];
+    NodeMatrix[n + NODE_OLD_DY] = NodeMatrix[n + NODE_DY];
+    NodeMatrix[n + NODE_DX] = 0;
+    NodeMatrix[n + NODE_DY] = 0;
+  }
+
+  // If outbound attraction distribution, compensate
+  if (options.outboundAttractionDistribution) {
+    outboundAttCompensation = 0;
+    for (n = 0; n < order; n += PPN) {
+      outboundAttCompensation += NodeMatrix[n + NODE_MASS];
+    }
+
+    outboundAttCompensation /= order / PPN;
+  }
+
+  // 1.bis) Barnes-Hut computation
+  //------------------------------
+
+  if (options.barnesHutOptimize) {
+    // Setting up
+    var minX = Infinity,
+      maxX = -Infinity,
+      minY = Infinity,
+      maxY = -Infinity,
+      q,
+      q2,
+      subdivisionAttempts;
+
+    // Computing min and max values
+    for (n = 0; n < order; n += PPN) {
+      minX = Math.min(minX, NodeMatrix[n + NODE_X]);
+      maxX = Math.max(maxX, NodeMatrix[n + NODE_X]);
+      minY = Math.min(minY, NodeMatrix[n + NODE_Y]);
+      maxY = Math.max(maxY, NodeMatrix[n + NODE_Y]);
+    }
+
+    // squarify bounds, it's a quadtree
+    var dx = maxX - minX,
+      dy = maxY - minY;
+    if (dx > dy) {
+      minY -= (dx - dy) / 2;
+      maxY = minY + dx;
+    } else {
+      minX -= (dy - dx) / 2;
+      maxX = minX + dy;
+    }
+
+    // Build the Barnes Hut root region
+    RegionMatrix[0 + REGION_NODE] = -1;
+    RegionMatrix[0 + REGION_CENTER_X] = (minX + maxX) / 2;
+    RegionMatrix[0 + REGION_CENTER_Y] = (minY + maxY) / 2;
+    RegionMatrix[0 + REGION_SIZE] = Math.max(maxX - minX, maxY - minY);
+    RegionMatrix[0 + REGION_NEXT_SIBLING] = -1;
+    RegionMatrix[0 + REGION_FIRST_CHILD] = -1;
+    RegionMatrix[0 + REGION_MASS] = 0;
+    RegionMatrix[0 + REGION_MASS_CENTER_X] = 0;
+    RegionMatrix[0 + REGION_MASS_CENTER_Y] = 0;
+
+    // Add each node in the tree
+    l = 1;
+    for (n = 0; n < order; n += PPN) {
+      // Current region, starting with root
+      r = 0;
+      subdivisionAttempts = SUBDIVISION_ATTEMPTS;
+
+      while (true) {
+        // Are there sub-regions?
+
+        // We look at first child index
+        if (RegionMatrix[r + REGION_FIRST_CHILD] >= 0) {
+          // There are sub-regions
+
+          // We just iterate to find a "leaf" of the tree
+          // that is an empty region or a region with a single node
+          // (see next case)
+
+          // Find the quadrant of n
+          if (NodeMatrix[n + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
+            if (NodeMatrix[n + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+              // Top Left quarter
+              q = RegionMatrix[r + REGION_FIRST_CHILD];
+            } else {
+              // Bottom Left quarter
+              q = RegionMatrix[r + REGION_FIRST_CHILD] + PPR;
+            }
+          } else {
+            if (NodeMatrix[n + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+              // Top Right quarter
+              q = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 2;
+            } else {
+              // Bottom Right quarter
+              q = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 3;
+            }
+          }
+
+          // Update center of mass and mass (we only do it for non-leave regions)
+          RegionMatrix[r + REGION_MASS_CENTER_X] =
+            (RegionMatrix[r + REGION_MASS_CENTER_X] *
+              RegionMatrix[r + REGION_MASS] +
+              NodeMatrix[n + NODE_X] * NodeMatrix[n + NODE_MASS]) /
+            (RegionMatrix[r + REGION_MASS] + NodeMatrix[n + NODE_MASS]);
+
+          RegionMatrix[r + REGION_MASS_CENTER_Y] =
+            (RegionMatrix[r + REGION_MASS_CENTER_Y] *
+              RegionMatrix[r + REGION_MASS] +
+              NodeMatrix[n + NODE_Y] * NodeMatrix[n + NODE_MASS]) /
+            (RegionMatrix[r + REGION_MASS] + NodeMatrix[n + NODE_MASS]);
+
+          RegionMatrix[r + REGION_MASS] += NodeMatrix[n + NODE_MASS];
+
+          // Iterate on the right quadrant
+          r = q;
+          continue;
+        } else {
+          // There are no sub-regions: we are in a "leaf"
+
+          // Is there a node in this leave?
+          if (RegionMatrix[r + REGION_NODE] < 0) {
+            // There is no node in region:
+            // we record node n and go on
+            RegionMatrix[r + REGION_NODE] = n;
+            break;
+          } else {
+            // There is a node in this region
+
+            // We will need to create sub-regions, stick the two
+            // nodes (the old one r[0] and the new one n) in two
+            // subregions. If they fall in the same quadrant,
+            // we will iterate.
+
+            // Create sub-regions
+            RegionMatrix[r + REGION_FIRST_CHILD] = l * PPR;
+            w = RegionMatrix[r + REGION_SIZE] / 2; // new size (half)
+
+            // NOTE: we use screen coordinates
+            // from Top Left to Bottom Right
+
+            // Top Left sub-region
+            g = RegionMatrix[r + REGION_FIRST_CHILD];
+
+            RegionMatrix[g + REGION_NODE] = -1;
+            RegionMatrix[g + REGION_CENTER_X] =
+              RegionMatrix[r + REGION_CENTER_X] - w;
+            RegionMatrix[g + REGION_CENTER_Y] =
+              RegionMatrix[r + REGION_CENTER_Y] - w;
+            RegionMatrix[g + REGION_SIZE] = w;
+            RegionMatrix[g + REGION_NEXT_SIBLING] = g + PPR;
+            RegionMatrix[g + REGION_FIRST_CHILD] = -1;
+            RegionMatrix[g + REGION_MASS] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_X] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_Y] = 0;
+
+            // Bottom Left sub-region
+            g += PPR;
+            RegionMatrix[g + REGION_NODE] = -1;
+            RegionMatrix[g + REGION_CENTER_X] =
+              RegionMatrix[r + REGION_CENTER_X] - w;
+            RegionMatrix[g + REGION_CENTER_Y] =
+              RegionMatrix[r + REGION_CENTER_Y] + w;
+            RegionMatrix[g + REGION_SIZE] = w;
+            RegionMatrix[g + REGION_NEXT_SIBLING] = g + PPR;
+            RegionMatrix[g + REGION_FIRST_CHILD] = -1;
+            RegionMatrix[g + REGION_MASS] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_X] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_Y] = 0;
+
+            // Top Right sub-region
+            g += PPR;
+            RegionMatrix[g + REGION_NODE] = -1;
+            RegionMatrix[g + REGION_CENTER_X] =
+              RegionMatrix[r + REGION_CENTER_X] + w;
+            RegionMatrix[g + REGION_CENTER_Y] =
+              RegionMatrix[r + REGION_CENTER_Y] - w;
+            RegionMatrix[g + REGION_SIZE] = w;
+            RegionMatrix[g + REGION_NEXT_SIBLING] = g + PPR;
+            RegionMatrix[g + REGION_FIRST_CHILD] = -1;
+            RegionMatrix[g + REGION_MASS] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_X] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_Y] = 0;
+
+            // Bottom Right sub-region
+            g += PPR;
+            RegionMatrix[g + REGION_NODE] = -1;
+            RegionMatrix[g + REGION_CENTER_X] =
+              RegionMatrix[r + REGION_CENTER_X] + w;
+            RegionMatrix[g + REGION_CENTER_Y] =
+              RegionMatrix[r + REGION_CENTER_Y] + w;
+            RegionMatrix[g + REGION_SIZE] = w;
+            RegionMatrix[g + REGION_NEXT_SIBLING] =
+              RegionMatrix[r + REGION_NEXT_SIBLING];
+            RegionMatrix[g + REGION_FIRST_CHILD] = -1;
+            RegionMatrix[g + REGION_MASS] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_X] = 0;
+            RegionMatrix[g + REGION_MASS_CENTER_Y] = 0;
+
+            l += 4;
+
+            // Now the goal is to find two different sub-regions
+            // for the two nodes: the one previously recorded (r[0])
+            // and the one we want to add (n)
+
+            // Find the quadrant of the old node
+            if (
+              NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_X] <
+              RegionMatrix[r + REGION_CENTER_X]
+            ) {
+              if (
+                NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_Y] <
+                RegionMatrix[r + REGION_CENTER_Y]
+              ) {
+                // Top Left quarter
+                q = RegionMatrix[r + REGION_FIRST_CHILD];
+              } else {
+                // Bottom Left quarter
+                q = RegionMatrix[r + REGION_FIRST_CHILD] + PPR;
+              }
+            } else {
+              if (
+                NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_Y] <
+                RegionMatrix[r + REGION_CENTER_Y]
+              ) {
+                // Top Right quarter
+                q = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 2;
+              } else {
+                // Bottom Right quarter
+                q = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 3;
+              }
+            }
+
+            // We remove r[0] from the region r, add its mass to r and record it in q
+            RegionMatrix[r + REGION_MASS] =
+              NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_MASS];
+            RegionMatrix[r + REGION_MASS_CENTER_X] =
+              NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_X];
+            RegionMatrix[r + REGION_MASS_CENTER_Y] =
+              NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_Y];
+
+            RegionMatrix[q + REGION_NODE] = RegionMatrix[r + REGION_NODE];
+            RegionMatrix[r + REGION_NODE] = -1;
+
+            // Find the quadrant of n
+            if (NodeMatrix[n + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
+              if (NodeMatrix[n + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+                // Top Left quarter
+                q2 = RegionMatrix[r + REGION_FIRST_CHILD];
+              } else {
+                // Bottom Left quarter
+                q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR;
+              }
+            } else {
+              if (NodeMatrix[n + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+                // Top Right quarter
+                q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 2;
+              } else {
+                // Bottom Right quarter
+                q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 3;
+              }
+            }
+
+            if (q === q2) {
+              // If both nodes are in the same quadrant,
+              // we have to try it again on this quadrant
+              if (subdivisionAttempts--) {
+                r = q;
+                continue; // while
+              } else {
+                // we are out of precision here, and we cannot subdivide anymore
+                // but we have to break the loop anyway
+                subdivisionAttempts = SUBDIVISION_ATTEMPTS;
+                break; // while
+              }
+            }
+
+            // If both quadrants are different, we record n
+            // in its quadrant
+            RegionMatrix[q2 + REGION_NODE] = n;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // 2) Repulsion
+  //--------------
+  // NOTES: adjustSizes = antiCollision & scalingRatio = coefficient
+
+  if (options.barnesHutOptimize) {
+    coefficient = options.scalingRatio;
+
+    // Applying repulsion through regions
+    for (n = 0; n < order; n += PPN) {
+      // Computing leaf quad nodes iteration
+
+      r = 0; // Starting with root region
+      while (true) {
+        if (RegionMatrix[r + REGION_FIRST_CHILD] >= 0) {
+          // The region has sub-regions
+
+          // We run the Barnes Hut test to see if we are at the right distance
+          distance =
+            Math.pow(
+              NodeMatrix[n + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X],
+              2
+            ) +
+            Math.pow(
+              NodeMatrix[n + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y],
+              2
+            );
+
+          s = RegionMatrix[r + REGION_SIZE];
+
+          if ((4 * s * s) / distance < thetaSquared) {
+            // We treat the region as a single body, and we repulse
+
+            xDist =
+              NodeMatrix[n + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X];
+            yDist =
+              NodeMatrix[n + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y];
+
+            if (adjustSizes === true) {
+              //-- Linear Anti-collision Repulsion
+              if (distance > 0) {
+                factor =
+                  (coefficient *
+                    NodeMatrix[n + NODE_MASS] *
+                    RegionMatrix[r + REGION_MASS]) /
+                  distance;
+
+                NodeMatrix[n + NODE_DX] += xDist * factor;
+                NodeMatrix[n + NODE_DY] += yDist * factor;
+              } else if (distance < 0) {
+                factor =
+                  (-coefficient *
+                    NodeMatrix[n + NODE_MASS] *
+                    RegionMatrix[r + REGION_MASS]) /
+                  Math.sqrt(distance);
+
+                NodeMatrix[n + NODE_DX] += xDist * factor;
+                NodeMatrix[n + NODE_DY] += yDist * factor;
+              }
+            } else {
+              //-- Linear Repulsion
+              if (distance > 0) {
+                factor =
+                  (coefficient *
+                    NodeMatrix[n + NODE_MASS] *
+                    RegionMatrix[r + REGION_MASS]) /
+                  distance;
+
+                NodeMatrix[n + NODE_DX] += xDist * factor;
+                NodeMatrix[n + NODE_DY] += yDist * factor;
+              }
+            }
+
+            // When this is done, we iterate. We have to look at the next sibling.
+            r = RegionMatrix[r + REGION_NEXT_SIBLING];
+            if (r < 0) break; // No next sibling: we have finished the tree
+
+            continue;
+          } else {
+            // The region is too close and we have to look at sub-regions
+            r = RegionMatrix[r + REGION_FIRST_CHILD];
+            continue;
+          }
+        } else {
+          // The region has no sub-region
+          // If there is a node r[0] and it is not n, then repulse
+          rn = RegionMatrix[r + REGION_NODE];
+
+          if (rn >= 0 && rn !== n) {
+            xDist = NodeMatrix[n + NODE_X] - NodeMatrix[rn + NODE_X];
+            yDist = NodeMatrix[n + NODE_Y] - NodeMatrix[rn + NODE_Y];
+
+            distance = xDist * xDist + yDist * yDist;
+
+            if (adjustSizes === true) {
+              //-- Linear Anti-collision Repulsion
+              if (distance > 0) {
+                factor =
+                  (coefficient *
+                    NodeMatrix[n + NODE_MASS] *
+                    NodeMatrix[rn + NODE_MASS]) /
+                  distance;
+
+                NodeMatrix[n + NODE_DX] += xDist * factor;
+                NodeMatrix[n + NODE_DY] += yDist * factor;
+              } else if (distance < 0) {
+                factor =
+                  (-coefficient *
+                    NodeMatrix[n + NODE_MASS] *
+                    NodeMatrix[rn + NODE_MASS]) /
+                  Math.sqrt(distance);
+
+                NodeMatrix[n + NODE_DX] += xDist * factor;
+                NodeMatrix[n + NODE_DY] += yDist * factor;
+              }
+            } else {
+              //-- Linear Repulsion
+              if (distance > 0) {
+                factor =
+                  (coefficient *
+                    NodeMatrix[n + NODE_MASS] *
+                    NodeMatrix[rn + NODE_MASS]) /
+                  distance;
+
+                NodeMatrix[n + NODE_DX] += xDist * factor;
+                NodeMatrix[n + NODE_DY] += yDist * factor;
+              }
+            }
+          }
+
+          // When this is done, we iterate. We have to look at the next sibling.
+          r = RegionMatrix[r + REGION_NEXT_SIBLING];
+
+          if (r < 0) break; // No next sibling: we have finished the tree
+
+          continue;
+        }
+      }
+    }
+  } else {
+    coefficient = options.scalingRatio;
+
+    // Square iteration
+    for (n1 = 0; n1 < order; n1 += PPN) {
+      for (n2 = 0; n2 < n1; n2 += PPN) {
+        // Common to both methods
+        xDist = NodeMatrix[n1 + NODE_X] - NodeMatrix[n2 + NODE_X];
+        yDist = NodeMatrix[n1 + NODE_Y] - NodeMatrix[n2 + NODE_Y];
+
+        if (adjustSizes === true) {
+          //-- Anticollision Linear Repulsion
+          distance =
+            Math.sqrt(xDist * xDist + yDist * yDist) -
+            NodeMatrix[n1 + NODE_SIZE] -
+            NodeMatrix[n2 + NODE_SIZE];
+
+          if (distance > 0) {
+            factor =
+              (coefficient *
+                NodeMatrix[n1 + NODE_MASS] *
+                NodeMatrix[n2 + NODE_MASS]) /
+              distance /
+              distance;
+
+            // Updating nodes' dx and dy
+            NodeMatrix[n1 + NODE_DX] += xDist * factor;
+            NodeMatrix[n1 + NODE_DY] += yDist * factor;
+
+            NodeMatrix[n2 + NODE_DX] -= xDist * factor;
+            NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+          } else if (distance < 0) {
+            factor =
+              100 *
+              coefficient *
+              NodeMatrix[n1 + NODE_MASS] *
+              NodeMatrix[n2 + NODE_MASS];
+
+            // Updating nodes' dx and dy
+            NodeMatrix[n1 + NODE_DX] += xDist * factor;
+            NodeMatrix[n1 + NODE_DY] += yDist * factor;
+
+            NodeMatrix[n2 + NODE_DX] -= xDist * factor;
+            NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+          }
+        } else {
+          //-- Linear Repulsion
+          distance = Math.sqrt(xDist * xDist + yDist * yDist);
+
+          if (distance > 0) {
+            factor =
+              (coefficient *
+                NodeMatrix[n1 + NODE_MASS] *
+                NodeMatrix[n2 + NODE_MASS]) /
+              distance /
+              distance;
+
+            // Updating nodes' dx and dy
+            NodeMatrix[n1 + NODE_DX] += xDist * factor;
+            NodeMatrix[n1 + NODE_DY] += yDist * factor;
+
+            NodeMatrix[n2 + NODE_DX] -= xDist * factor;
+            NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+          }
+        }
+      }
+    }
+  }
+
+  // 3) Gravity
+  //------------
+  g = options.gravity / options.scalingRatio;
+  coefficient = options.scalingRatio;
+  for (n = 0; n < order; n += PPN) {
+    factor = 0;
+
+    // Common to both methods
+    xDist = NodeMatrix[n + NODE_X];
+    yDist = NodeMatrix[n + NODE_Y];
+    distance = Math.sqrt(Math.pow(xDist, 2) + Math.pow(yDist, 2));
+
+    if (options.strongGravityMode) {
+      //-- Strong gravity
+      if (distance > 0) factor = coefficient * NodeMatrix[n + NODE_MASS] * g;
+    } else {
+      //-- Linear Anti-collision Repulsion n
+      if (distance > 0)
+        factor = (coefficient * NodeMatrix[n + NODE_MASS] * g) / distance;
+    }
+
+    // Updating node's dx and dy
+    NodeMatrix[n + NODE_DX] -= xDist * factor;
+    NodeMatrix[n + NODE_DY] -= yDist * factor;
+  }
+
+  // 4) Attraction
+  //---------------
+  coefficient =
+    1 * (options.outboundAttractionDistribution ? outboundAttCompensation : 1);
+
+  // TODO: simplify distance
+  // TODO: coefficient is always used as -c --> optimize?
+  for (e = 0; e < size; e += PPE) {
+    n1 = EdgeMatrix[e + EDGE_SOURCE];
+    n2 = EdgeMatrix[e + EDGE_TARGET];
+    w = EdgeMatrix[e + EDGE_WEIGHT];
+
+    // Edge weight influence
+    ewc = Math.pow(w, options.edgeWeightInfluence);
+
+    // Common measures
+    xDist = NodeMatrix[n1 + NODE_X] - NodeMatrix[n2 + NODE_X];
+    yDist = NodeMatrix[n1 + NODE_Y] - NodeMatrix[n2 + NODE_Y];
+
+    // Applying attraction to nodes
+    if (adjustSizes === true) {
+      distance =
+        Math.sqrt(xDist * xDist + yDist * yDist) -
+        NodeMatrix[n1 + NODE_SIZE] -
+        NodeMatrix[n2 + NODE_SIZE];
+
+      if (options.linLogMode) {
+        if (options.outboundAttractionDistribution) {
+          //-- LinLog Degree Distributed Anti-collision Attraction
+          if (distance > 0) {
+            factor =
+              (-coefficient * ewc * Math.log(1 + distance)) /
+              distance /
+              NodeMatrix[n1 + NODE_MASS];
+          }
+        } else {
+          //-- LinLog Anti-collision Attraction
+          if (distance > 0) {
+            factor = (-coefficient * ewc * Math.log(1 + distance)) / distance;
+          }
+        }
+      } else {
+        if (options.outboundAttractionDistribution) {
+          //-- Linear Degree Distributed Anti-collision Attraction
+          if (distance > 0) {
+            factor = (-coefficient * ewc) / NodeMatrix[n1 + NODE_MASS];
+          }
+        } else {
+          //-- Linear Anti-collision Attraction
+          if (distance > 0) {
+            factor = -coefficient * ewc;
+          }
+        }
+      }
+    } else {
+      distance = Math.sqrt(Math.pow(xDist, 2) + Math.pow(yDist, 2));
+
+      if (options.linLogMode) {
+        if (options.outboundAttractionDistribution) {
+          //-- LinLog Degree Distributed Attraction
+          if (distance > 0) {
+            factor =
+              (-coefficient * ewc * Math.log(1 + distance)) /
+              distance /
+              NodeMatrix[n1 + NODE_MASS];
+          }
+        } else {
+          //-- LinLog Attraction
+          if (distance > 0)
+            factor = (-coefficient * ewc * Math.log(1 + distance)) / distance;
+        }
+      } else {
+        if (options.outboundAttractionDistribution) {
+          //-- Linear Attraction Mass Distributed
+          // NOTE: Distance is set to 1 to override next condition
+          distance = 1;
+          factor = (-coefficient * ewc) / NodeMatrix[n1 + NODE_MASS];
+        } else {
+          //-- Linear Attraction
+          // NOTE: Distance is set to 1 to override next condition
+          distance = 1;
+          factor = -coefficient * ewc;
+        }
+      }
+    }
+
+    // Updating nodes' dx and dy
+    // TODO: if condition or factor = 1?
+    if (distance > 0) {
+      // Updating nodes' dx and dy
+      NodeMatrix[n1 + NODE_DX] += xDist * factor;
+      NodeMatrix[n1 + NODE_DY] += yDist * factor;
+
+      NodeMatrix[n2 + NODE_DX] -= xDist * factor;
+      NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+    }
+  }
+
+  // 5) Apply Forces
+  //-----------------
+  var force, swinging, traction, nodespeed, newX, newY;
+
+  // MATH: sqrt and square distances
+  if (adjustSizes === true) {
+    for (n = 0; n < order; n += PPN) {
+      if (NodeMatrix[n + NODE_FIXED] !== 1) {
+        force = Math.sqrt(
+          Math.pow(NodeMatrix[n + NODE_DX], 2) +
+            Math.pow(NodeMatrix[n + NODE_DY], 2)
+        );
+
+        if (force > MAX_FORCE) {
+          NodeMatrix[n + NODE_DX] =
+            (NodeMatrix[n + NODE_DX] * MAX_FORCE) / force;
+          NodeMatrix[n + NODE_DY] =
+            (NodeMatrix[n + NODE_DY] * MAX_FORCE) / force;
+        }
+
+        swinging =
+          NodeMatrix[n + NODE_MASS] *
+          Math.sqrt(
+            (NodeMatrix[n + NODE_OLD_DX] - NodeMatrix[n + NODE_DX]) *
+              (NodeMatrix[n + NODE_OLD_DX] - NodeMatrix[n + NODE_DX]) +
+              (NodeMatrix[n + NODE_OLD_DY] - NodeMatrix[n + NODE_DY]) *
+                (NodeMatrix[n + NODE_OLD_DY] - NodeMatrix[n + NODE_DY])
+          );
+
+        traction =
+          Math.sqrt(
+            (NodeMatrix[n + NODE_OLD_DX] + NodeMatrix[n + NODE_DX]) *
+              (NodeMatrix[n + NODE_OLD_DX] + NodeMatrix[n + NODE_DX]) +
+              (NodeMatrix[n + NODE_OLD_DY] + NodeMatrix[n + NODE_DY]) *
+                (NodeMatrix[n + NODE_OLD_DY] + NodeMatrix[n + NODE_DY])
+          ) / 2;
+
+        nodespeed = (0.1 * Math.log(1 + traction)) / (1 + Math.sqrt(swinging));
+
+        // Updating node's positon
+        newX =
+          NodeMatrix[n + NODE_X] +
+          NodeMatrix[n + NODE_DX] * (nodespeed / options.slowDown);
+        NodeMatrix[n + NODE_X] = newX;
+
+        newY =
+          NodeMatrix[n + NODE_Y] +
+          NodeMatrix[n + NODE_DY] * (nodespeed / options.slowDown);
+        NodeMatrix[n + NODE_Y] = newY;
+      }
+    }
+  } else {
+    for (n = 0; n < order; n += PPN) {
+      if (NodeMatrix[n + NODE_FIXED] !== 1) {
+        swinging =
+          NodeMatrix[n + NODE_MASS] *
+          Math.sqrt(
+            (NodeMatrix[n + NODE_OLD_DX] - NodeMatrix[n + NODE_DX]) *
+              (NodeMatrix[n + NODE_OLD_DX] - NodeMatrix[n + NODE_DX]) +
+              (NodeMatrix[n + NODE_OLD_DY] - NodeMatrix[n + NODE_DY]) *
+                (NodeMatrix[n + NODE_OLD_DY] - NodeMatrix[n + NODE_DY])
+          );
+
+        traction =
+          Math.sqrt(
+            (NodeMatrix[n + NODE_OLD_DX] + NodeMatrix[n + NODE_DX]) *
+              (NodeMatrix[n + NODE_OLD_DX] + NodeMatrix[n + NODE_DX]) +
+              (NodeMatrix[n + NODE_OLD_DY] + NodeMatrix[n + NODE_DY]) *
+                (NodeMatrix[n + NODE_OLD_DY] + NodeMatrix[n + NODE_DY])
+          ) / 2;
+
+        nodespeed =
+          (NodeMatrix[n + NODE_CONVERGENCE] * Math.log(1 + traction)) /
+          (1 + Math.sqrt(swinging));
+
+        // Updating node convergence
+        NodeMatrix[n + NODE_CONVERGENCE] = Math.min(
+          1,
+          Math.sqrt(
+            (nodespeed *
+              (Math.pow(NodeMatrix[n + NODE_DX], 2) +
+                Math.pow(NodeMatrix[n + NODE_DY], 2))) /
+              (1 + Math.sqrt(swinging))
+          )
+        );
+
+        // Updating node's positon
+        newX =
+          NodeMatrix[n + NODE_X] +
+          NodeMatrix[n + NODE_DX] * (nodespeed / options.slowDown);
+        NodeMatrix[n + NODE_X] = newX;
+
+        newY =
+          NodeMatrix[n + NODE_Y] +
+          NodeMatrix[n + NODE_DY] * (nodespeed / options.slowDown);
+        NodeMatrix[n + NODE_Y] = newY;
+      }
+    }
+  }
+
+  // We return the information about the layout (no need to return the matrices)
+  return {};
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/graphology-utils/getters.js":
+/*!**************************************************!*\
+  !*** ./node_modules/graphology-utils/getters.js ***!
+  \**************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+/**
+ * Graphology Weight Getter
+ * =========================
+ *
+ * Function creating weight getters.
+ */
+function coerceWeight(value) {
+  // Ensuring target value is a correct number
+  if (typeof value !== 'number' || isNaN(value)) return 1;
+
+  return value;
+}
+
+function createNodeValueGetter(nameOrFunction, defaultValue) {
+  var getter = {};
+
+  var coerceToDefault = function (v) {
+    if (typeof v === 'undefined') return defaultValue;
+
+    return v;
+  };
+
+  if (typeof defaultValue === 'function') coerceToDefault = defaultValue;
+
+  var get = function (attributes) {
+    return coerceToDefault(attributes[nameOrFunction]);
+  };
+
+  var returnDefault = function () {
+    return coerceToDefault(undefined);
+  };
+
+  if (typeof nameOrFunction === 'string') {
+    getter.fromAttributes = get;
+    getter.fromGraph = function (graph, node) {
+      return get(graph.getNodeAttributes(node));
+    };
+    getter.fromEntry = function (node, attributes) {
+      return get(attributes);
+    };
+  } else if (typeof nameOrFunction === 'function') {
+    getter.fromAttributes = function () {
+      throw new Error(
+        'graphology-utils/getters/createNodeValueGetter: irrelevant usage.'
+      );
+    };
+    getter.fromGraph = function (graph, node) {
+      return coerceToDefault(
+        nameOrFunction(node, graph.getNodeAttributes(node))
+      );
+    };
+    getter.fromEntry = function (node, attributes) {
+      return coerceToDefault(nameOrFunction(node, attributes));
+    };
+  } else {
+    getter.fromAttributes = returnDefault;
+    getter.fromGraph = returnDefault;
+    getter.fromEntry = returnDefault;
+  }
+
+  return getter;
+}
+
+function createEdgeValueGetter(nameOrFunction, defaultValue) {
+  var getter = {};
+
+  var coerceToDefault = function (v) {
+    if (typeof v === 'undefined') return defaultValue;
+
+    return v;
+  };
+
+  if (typeof defaultValue === 'function') coerceToDefault = defaultValue;
+
+  var get = function (attributes) {
+    return coerceToDefault(attributes[nameOrFunction]);
+  };
+
+  var returnDefault = function () {
+    return coerceToDefault(undefined);
+  };
+
+  if (typeof nameOrFunction === 'string') {
+    getter.fromAttributes = get;
+    getter.fromGraph = function (graph, edge) {
+      return get(graph.getEdgeAttributes(edge));
+    };
+    getter.fromEntry = function (edge, attributes) {
+      return get(attributes);
+    };
+    getter.fromPartialEntry = getter.fromEntry;
+    getter.fromMinimalEntry = getter.fromEntry;
+  } else if (typeof nameOrFunction === 'function') {
+    getter.fromAttributes = function () {
+      throw new Error(
+        'graphology-utils/getters/createEdgeValueGetter: irrelevant usage.'
+      );
+    };
+    getter.fromGraph = function (graph, edge) {
+      // TODO: we can do better, check #310
+      var extremities = graph.extremities(edge);
+      return coerceToDefault(
+        nameOrFunction(
+          edge,
+          graph.getEdgeAttributes(edge),
+          extremities[0],
+          extremities[1],
+          graph.getNodeAttributes(extremities[0]),
+          graph.getNodeAttributes(extremities[1]),
+          graph.isUndirected(edge)
+        )
+      );
+    };
+    getter.fromEntry = function (e, a, s, t, sa, ta, u) {
+      return coerceToDefault(nameOrFunction(e, a, s, t, sa, ta, u));
+    };
+    getter.fromPartialEntry = function (e, a, s, t) {
+      return coerceToDefault(nameOrFunction(e, a, s, t));
+    };
+    getter.fromMinimalEntry = function (e, a) {
+      return coerceToDefault(nameOrFunction(e, a));
+    };
+  } else {
+    getter.fromAttributes = returnDefault;
+    getter.fromGraph = returnDefault;
+    getter.fromEntry = returnDefault;
+    getter.fromMinimalEntry = returnDefault;
+  }
+
+  return getter;
+}
+
+exports.createNodeValueGetter = createNodeValueGetter;
+exports.createEdgeValueGetter = createEdgeValueGetter;
+exports.createEdgeWeightGetter = function (name) {
+  return createEdgeValueGetter(name, coerceWeight);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/graphology-utils/is-graph.js":
+/*!***************************************************!*\
+  !*** ./node_modules/graphology-utils/is-graph.js ***!
+  \***************************************************/
+/***/ ((module) => {
+
+/**
+ * Graphology isGraph
+ * ===================
+ *
+ * Very simple function aiming at ensuring the given variable is a
+ * graphology instance.
+ */
+
+/**
+ * Checking the value is a graphology instance.
+ *
+ * @param  {any}     value - Target value.
+ * @return {boolean}
+ */
+module.exports = function isGraph(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof value.addUndirectedEdgeWithKey === 'function' &&
+    typeof value.dropNode === 'function' &&
+    typeof value.multi === 'boolean'
+  );
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/graphology/dist/graphology.umd.min.js":
+/*!************************************************************!*\
+  !*** ./node_modules/graphology/dist/graphology.umd.min.js ***!
+  \************************************************************/
+/***/ (function(module) {
+
+!function(t,e){ true?module.exports=e():0}(this,(function(){"use strict";function t(e){return t="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},t(e)}function e(t,e){t.prototype=Object.create(e.prototype),t.prototype.constructor=t,r(t,e)}function n(t){return n=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(t){return t.__proto__||Object.getPrototypeOf(t)},n(t)}function r(t,e){return r=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t},r(t,e)}function i(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}function o(t,e,n){return o=i()?Reflect.construct.bind():function(t,e,n){var i=[null];i.push.apply(i,e);var o=new(Function.bind.apply(t,i));return n&&r(o,n.prototype),o},o.apply(null,arguments)}function a(t){var e="function"==typeof Map?new Map:void 0;return a=function(t){if(null===t||(i=t,-1===Function.toString.call(i).indexOf("[native code]")))return t;var i;if("function"!=typeof t)throw new TypeError("Super expression must either be null or a function");if(void 0!==e){if(e.has(t))return e.get(t);e.set(t,a)}function a(){return o(t,arguments,n(this).constructor)}return a.prototype=Object.create(t.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),r(a,t)},a(t)}function c(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}var u=function(){for(var t=arguments[0],e=1,n=arguments.length;e<n;e++)if(arguments[e])for(var r in arguments[e])t[r]=arguments[e][r];return t};function d(t,e,n,r){var i=t._nodes.get(e),o=null;return i?o="mixed"===r?i.out&&i.out[n]||i.undirected&&i.undirected[n]:"directed"===r?i.out&&i.out[n]:i.undirected&&i.undirected[n]:o}function s(e){return"object"===t(e)&&null!==e}function h(t){var e;for(e in t)return!1;return!0}function p(t,e,n){Object.defineProperty(t,e,{enumerable:!1,configurable:!1,writable:!0,value:n})}function f(t,e,n){var r={enumerable:!0,configurable:!0};"function"==typeof n?r.get=n:(r.value=n,r.writable=!1),Object.defineProperty(t,e,r)}function l(t){return!!s(t)&&!(t.attributes&&!Array.isArray(t.attributes))}"function"==typeof Object.assign&&(u=Object.assign);var g,y={exports:{}},w="object"==typeof Reflect?Reflect:null,v=w&&"function"==typeof w.apply?w.apply:function(t,e,n){return Function.prototype.apply.call(t,e,n)};g=w&&"function"==typeof w.ownKeys?w.ownKeys:Object.getOwnPropertySymbols?function(t){return Object.getOwnPropertyNames(t).concat(Object.getOwnPropertySymbols(t))}:function(t){return Object.getOwnPropertyNames(t)};var b=Number.isNaN||function(t){return t!=t};function m(){m.init.call(this)}y.exports=m,y.exports.once=function(t,e){return new Promise((function(n,r){function i(n){t.removeListener(e,o),r(n)}function o(){"function"==typeof t.removeListener&&t.removeListener("error",i),n([].slice.call(arguments))}U(t,e,o,{once:!0}),"error"!==e&&function(t,e,n){"function"==typeof t.on&&U(t,"error",e,n)}(t,i,{once:!0})}))},m.EventEmitter=m,m.prototype._events=void 0,m.prototype._eventsCount=0,m.prototype._maxListeners=void 0;var k=10;function _(t){if("function"!=typeof t)throw new TypeError('The "listener" argument must be of type Function. Received type '+typeof t)}function G(t){return void 0===t._maxListeners?m.defaultMaxListeners:t._maxListeners}function x(t,e,n,r){var i,o,a,c;if(_(n),void 0===(o=t._events)?(o=t._events=Object.create(null),t._eventsCount=0):(void 0!==o.newListener&&(t.emit("newListener",e,n.listener?n.listener:n),o=t._events),a=o[e]),void 0===a)a=o[e]=n,++t._eventsCount;else if("function"==typeof a?a=o[e]=r?[n,a]:[a,n]:r?a.unshift(n):a.push(n),(i=G(t))>0&&a.length>i&&!a.warned){a.warned=!0;var u=new Error("Possible EventEmitter memory leak detected. "+a.length+" "+String(e)+" listeners added. Use emitter.setMaxListeners() to increase limit");u.name="MaxListenersExceededWarning",u.emitter=t,u.type=e,u.count=a.length,c=u,console&&console.warn&&console.warn(c)}return t}function E(){if(!this.fired)return this.target.removeListener(this.type,this.wrapFn),this.fired=!0,0===arguments.length?this.listener.call(this.target):this.listener.apply(this.target,arguments)}function A(t,e,n){var r={fired:!1,wrapFn:void 0,target:t,type:e,listener:n},i=E.bind(r);return i.listener=n,r.wrapFn=i,i}function L(t,e,n){var r=t._events;if(void 0===r)return[];var i=r[e];return void 0===i?[]:"function"==typeof i?n?[i.listener||i]:[i]:n?function(t){for(var e=new Array(t.length),n=0;n<e.length;++n)e[n]=t[n].listener||t[n];return e}(i):D(i,i.length)}function S(t){var e=this._events;if(void 0!==e){var n=e[t];if("function"==typeof n)return 1;if(void 0!==n)return n.length}return 0}function D(t,e){for(var n=new Array(e),r=0;r<e;++r)n[r]=t[r];return n}function U(t,e,n,r){if("function"==typeof t.on)r.once?t.once(e,n):t.on(e,n);else{if("function"!=typeof t.addEventListener)throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type '+typeof t);t.addEventListener(e,(function i(o){r.once&&t.removeEventListener(e,i),n(o)}))}}function N(t){if("function"!=typeof t)throw new Error("obliterator/iterator: expecting a function!");this.next=t}Object.defineProperty(m,"defaultMaxListeners",{enumerable:!0,get:function(){return k},set:function(t){if("number"!=typeof t||t<0||b(t))throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received '+t+".");k=t}}),m.init=function(){void 0!==this._events&&this._events!==Object.getPrototypeOf(this)._events||(this._events=Object.create(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0},m.prototype.setMaxListeners=function(t){if("number"!=typeof t||t<0||b(t))throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received '+t+".");return this._maxListeners=t,this},m.prototype.getMaxListeners=function(){return G(this)},m.prototype.emit=function(t){for(var e=[],n=1;n<arguments.length;n++)e.push(arguments[n]);var r="error"===t,i=this._events;if(void 0!==i)r=r&&void 0===i.error;else if(!r)return!1;if(r){var o;if(e.length>0&&(o=e[0]),o instanceof Error)throw o;var a=new Error("Unhandled error."+(o?" ("+o.message+")":""));throw a.context=o,a}var c=i[t];if(void 0===c)return!1;if("function"==typeof c)v(c,this,e);else{var u=c.length,d=D(c,u);for(n=0;n<u;++n)v(d[n],this,e)}return!0},m.prototype.addListener=function(t,e){return x(this,t,e,!1)},m.prototype.on=m.prototype.addListener,m.prototype.prependListener=function(t,e){return x(this,t,e,!0)},m.prototype.once=function(t,e){return _(e),this.on(t,A(this,t,e)),this},m.prototype.prependOnceListener=function(t,e){return _(e),this.prependListener(t,A(this,t,e)),this},m.prototype.removeListener=function(t,e){var n,r,i,o,a;if(_(e),void 0===(r=this._events))return this;if(void 0===(n=r[t]))return this;if(n===e||n.listener===e)0==--this._eventsCount?this._events=Object.create(null):(delete r[t],r.removeListener&&this.emit("removeListener",t,n.listener||e));else if("function"!=typeof n){for(i=-1,o=n.length-1;o>=0;o--)if(n[o]===e||n[o].listener===e){a=n[o].listener,i=o;break}if(i<0)return this;0===i?n.shift():function(t,e){for(;e+1<t.length;e++)t[e]=t[e+1];t.pop()}(n,i),1===n.length&&(r[t]=n[0]),void 0!==r.removeListener&&this.emit("removeListener",t,a||e)}return this},m.prototype.off=m.prototype.removeListener,m.prototype.removeAllListeners=function(t){var e,n,r;if(void 0===(n=this._events))return this;if(void 0===n.removeListener)return 0===arguments.length?(this._events=Object.create(null),this._eventsCount=0):void 0!==n[t]&&(0==--this._eventsCount?this._events=Object.create(null):delete n[t]),this;if(0===arguments.length){var i,o=Object.keys(n);for(r=0;r<o.length;++r)"removeListener"!==(i=o[r])&&this.removeAllListeners(i);return this.removeAllListeners("removeListener"),this._events=Object.create(null),this._eventsCount=0,this}if("function"==typeof(e=n[t]))this.removeListener(t,e);else if(void 0!==e)for(r=e.length-1;r>=0;r--)this.removeListener(t,e[r]);return this},m.prototype.listeners=function(t){return L(this,t,!0)},m.prototype.rawListeners=function(t){return L(this,t,!1)},m.listenerCount=function(t,e){return"function"==typeof t.listenerCount?t.listenerCount(e):S.call(t,e)},m.prototype.listenerCount=S,m.prototype.eventNames=function(){return this._eventsCount>0?g(this._events):[]},"undefined"!=typeof Symbol&&(N.prototype[Symbol.iterator]=function(){return this}),N.of=function(){var t=arguments,e=t.length,n=0;return new N((function(){return n>=e?{done:!0}:{done:!1,value:t[n++]}}))},N.empty=function(){return new N((function(){return{done:!0}}))},N.fromSequence=function(t){var e=0,n=t.length;return new N((function(){return e>=n?{done:!0}:{done:!1,value:t[e++]}}))},N.is=function(t){return t instanceof N||"object"==typeof t&&null!==t&&"function"==typeof t.next};var O=N,j={};j.ARRAY_BUFFER_SUPPORT="undefined"!=typeof ArrayBuffer,j.SYMBOL_SUPPORT="undefined"!=typeof Symbol;var C=O,M=j,z=M.ARRAY_BUFFER_SUPPORT,W=M.SYMBOL_SUPPORT;var P=function(t){var e=function(t){return"string"==typeof t||Array.isArray(t)||z&&ArrayBuffer.isView(t)?C.fromSequence(t):"object"!=typeof t||null===t?null:W&&"function"==typeof t[Symbol.iterator]?t[Symbol.iterator]():"function"==typeof t.next?t:null}(t);if(!e)throw new Error("obliterator: target is not iterable nor a valid iterator.");return e},R=P,K=function(t,e){for(var n,r=arguments.length>1?e:1/0,i=r!==1/0?new Array(r):[],o=0,a=R(t);;){if(o===r)return i;if((n=a.next()).done)return o!==e&&(i.length=o),i;i[o++]=n.value}},T=function(t){function n(e){var n;return(n=t.call(this)||this).name="GraphError",n.message=e,n}return e(n,t),n}(a(Error)),B=function(t){function n(e){var r;return(r=t.call(this,e)||this).name="InvalidArgumentsGraphError","function"==typeof Error.captureStackTrace&&Error.captureStackTrace(c(r),n.prototype.constructor),r}return e(n,t),n}(T),F=function(t){function n(e){var r;return(r=t.call(this,e)||this).name="NotFoundGraphError","function"==typeof Error.captureStackTrace&&Error.captureStackTrace(c(r),n.prototype.constructor),r}return e(n,t),n}(T),I=function(t){function n(e){var r;return(r=t.call(this,e)||this).name="UsageGraphError","function"==typeof Error.captureStackTrace&&Error.captureStackTrace(c(r),n.prototype.constructor),r}return e(n,t),n}(T);function Y(t,e){this.key=t,this.attributes=e,this.clear()}function q(t,e){this.key=t,this.attributes=e,this.clear()}function J(t,e){this.key=t,this.attributes=e,this.clear()}function V(t,e,n,r,i){this.key=e,this.attributes=i,this.undirected=t,this.source=n,this.target=r}Y.prototype.clear=function(){this.inDegree=0,this.outDegree=0,this.undirectedDegree=0,this.undirectedLoops=0,this.directedLoops=0,this.in={},this.out={},this.undirected={}},q.prototype.clear=function(){this.inDegree=0,this.outDegree=0,this.directedLoops=0,this.in={},this.out={}},J.prototype.clear=function(){this.undirectedDegree=0,this.undirectedLoops=0,this.undirected={}},V.prototype.attach=function(){var t="out",e="in";this.undirected&&(t=e="undirected");var n=this.source.key,r=this.target.key;this.source[t][r]=this,this.undirected&&n===r||(this.target[e][n]=this)},V.prototype.attachMulti=function(){var t="out",e="in",n=this.source.key,r=this.target.key;this.undirected&&(t=e="undirected");var i=this.source[t],o=i[r];if(void 0===o)return i[r]=this,void(this.undirected&&n===r||(this.target[e][n]=this));o.previous=this,this.next=o,i[r]=this,this.target[e][n]=this},V.prototype.detach=function(){var t=this.source.key,e=this.target.key,n="out",r="in";this.undirected&&(n=r="undirected"),delete this.source[n][e],delete this.target[r][t]},V.prototype.detachMulti=function(){var t=this.source.key,e=this.target.key,n="out",r="in";this.undirected&&(n=r="undirected"),void 0===this.previous?void 0===this.next?(delete this.source[n][e],delete this.target[r][t]):(this.next.previous=void 0,this.source[n][e]=this.next,this.target[r][t]=this.next):(this.previous.next=this.next,void 0!==this.next&&(this.next.previous=this.previous))};function H(t,e,n,r,i,o,a){var c,u,d,s;if(r=""+r,0===n){if(!(c=t._nodes.get(r)))throw new F("Graph.".concat(e,': could not find the "').concat(r,'" node in the graph.'));d=i,s=o}else if(3===n){if(i=""+i,!(u=t._edges.get(i)))throw new F("Graph.".concat(e,': could not find the "').concat(i,'" edge in the graph.'));var h=u.source.key,p=u.target.key;if(r===h)c=u.target;else{if(r!==p)throw new F("Graph.".concat(e,': the "').concat(r,'" node is not attached to the "').concat(i,'" edge (').concat(h,", ").concat(p,")."));c=u.source}d=o,s=a}else{if(!(u=t._edges.get(r)))throw new F("Graph.".concat(e,': could not find the "').concat(r,'" edge in the graph.'));c=1===n?u.source:u.target,d=i,s=o}return[c,d,s]}var Q=[{name:function(t){return"get".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o=H(this,e,n,t,r,i),a=o[0],c=o[1];return a.attributes[c]}}},{name:function(t){return"get".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t,r){return H(this,e,n,t,r)[0].attributes}}},{name:function(t){return"has".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o=H(this,e,n,t,r,i),a=o[0],c=o[1];return a.attributes.hasOwnProperty(c)}}},{name:function(t){return"set".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i,o){var a=H(this,e,n,t,r,i,o),c=a[0],u=a[1],d=a[2];return c.attributes[u]=d,this.emit("nodeAttributesUpdated",{key:c.key,type:"set",attributes:c.attributes,name:u}),this}}},{name:function(t){return"update".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i,o){var a=H(this,e,n,t,r,i,o),c=a[0],u=a[1],d=a[2];if("function"!=typeof d)throw new B("Graph.".concat(e,": updater should be a function."));var s=c.attributes,h=d(s[u]);return s[u]=h,this.emit("nodeAttributesUpdated",{key:c.key,type:"set",attributes:c.attributes,name:u}),this}}},{name:function(t){return"remove".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o=H(this,e,n,t,r,i),a=o[0],c=o[1];return delete a.attributes[c],this.emit("nodeAttributesUpdated",{key:a.key,type:"remove",attributes:a.attributes,name:c}),this}}},{name:function(t){return"replace".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o=H(this,e,n,t,r,i),a=o[0],c=o[1];if(!s(c))throw new B("Graph.".concat(e,": provided attributes are not a plain object."));return a.attributes=c,this.emit("nodeAttributesUpdated",{key:a.key,type:"replace",attributes:a.attributes}),this}}},{name:function(t){return"merge".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o=H(this,e,n,t,r,i),a=o[0],c=o[1];if(!s(c))throw new B("Graph.".concat(e,": provided attributes are not a plain object."));return u(a.attributes,c),this.emit("nodeAttributesUpdated",{key:a.key,type:"merge",attributes:a.attributes,data:c}),this}}},{name:function(t){return"update".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o=H(this,e,n,t,r,i),a=o[0],c=o[1];if("function"!=typeof c)throw new B("Graph.".concat(e,": provided updater is not a function."));return a.attributes=c(a.attributes),this.emit("nodeAttributesUpdated",{key:a.key,type:"update",attributes:a.attributes}),this}}}];var X=[{name:function(t){return"get".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r){var i;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>2){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var o=""+t,a=""+r;if(r=arguments[2],!(i=d(this,o,a,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(o,'" - "').concat(a,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(i=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}return i.attributes[r]}}},{name:function(t){return"get".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t){var r;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>1){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var i=""+t,o=""+arguments[1];if(!(r=d(this,i,o,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(i,'" - "').concat(o,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(r=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}return r.attributes}}},{name:function(t){return"has".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r){var i;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>2){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var o=""+t,a=""+r;if(r=arguments[2],!(i=d(this,o,a,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(o,'" - "').concat(a,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(i=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}return i.attributes.hasOwnProperty(r)}}},{name:function(t){return"set".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>3){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var a=""+t,c=""+r;if(r=arguments[2],i=arguments[3],!(o=d(this,a,c,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(a,'" - "').concat(c,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(o=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}return o.attributes[r]=i,this.emit("edgeAttributesUpdated",{key:o.key,type:"set",attributes:o.attributes,name:r}),this}}},{name:function(t){return"update".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r,i){var o;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>3){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var a=""+t,c=""+r;if(r=arguments[2],i=arguments[3],!(o=d(this,a,c,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(a,'" - "').concat(c,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(o=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}if("function"!=typeof i)throw new B("Graph.".concat(e,": updater should be a function."));return o.attributes[r]=i(o.attributes[r]),this.emit("edgeAttributesUpdated",{key:o.key,type:"set",attributes:o.attributes,name:r}),this}}},{name:function(t){return"remove".concat(t,"Attribute")},attacher:function(t,e,n){t.prototype[e]=function(t,r){var i;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>2){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var o=""+t,a=""+r;if(r=arguments[2],!(i=d(this,o,a,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(o,'" - "').concat(a,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(i=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}return delete i.attributes[r],this.emit("edgeAttributesUpdated",{key:i.key,type:"remove",attributes:i.attributes,name:r}),this}}},{name:function(t){return"replace".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t,r){var i;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>2){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var o=""+t,a=""+r;if(r=arguments[2],!(i=d(this,o,a,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(o,'" - "').concat(a,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(i=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}if(!s(r))throw new B("Graph.".concat(e,": provided attributes are not a plain object."));return i.attributes=r,this.emit("edgeAttributesUpdated",{key:i.key,type:"replace",attributes:i.attributes}),this}}},{name:function(t){return"merge".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t,r){var i;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>2){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var o=""+t,a=""+r;if(r=arguments[2],!(i=d(this,o,a,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(o,'" - "').concat(a,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(i=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}if(!s(r))throw new B("Graph.".concat(e,": provided attributes are not a plain object."));return u(i.attributes,r),this.emit("edgeAttributesUpdated",{key:i.key,type:"merge",attributes:i.attributes,data:r}),this}}},{name:function(t){return"update".concat(t,"Attributes")},attacher:function(t,e,n){t.prototype[e]=function(t,r){var i;if("mixed"!==this.type&&"mixed"!==n&&n!==this.type)throw new I("Graph.".concat(e,": cannot find this type of edges in your ").concat(this.type," graph."));if(arguments.length>2){if(this.multi)throw new I("Graph.".concat(e,": cannot use a {source,target} combo when asking about an edge's attributes in a MultiGraph since we cannot infer the one you want information about."));var o=""+t,a=""+r;if(r=arguments[2],!(i=d(this,o,a,n)))throw new F("Graph.".concat(e,': could not find an edge for the given path ("').concat(o,'" - "').concat(a,'").'))}else{if("mixed"!==n)throw new I("Graph.".concat(e,": calling this method with only a key (vs. a source and target) does not make sense since an edge with this key could have the other type."));if(t=""+t,!(i=this._edges.get(t)))throw new F("Graph.".concat(e,': could not find the "').concat(t,'" edge in the graph.'))}if("function"!=typeof r)throw new B("Graph.".concat(e,": provided updater is not a function."));return i.attributes=r(i.attributes),this.emit("edgeAttributesUpdated",{key:i.key,type:"update",attributes:i.attributes}),this}}}];var Z=O,$=P,tt=function(){var t=arguments,e=null,n=-1;return new Z((function(){for(var r=null;;){if(null===e){if(++n>=t.length)return{done:!0};e=$(t[n])}if(!0!==(r=e.next()).done)break;e=null}return r}))},et=[{name:"edges",type:"mixed"},{name:"inEdges",type:"directed",direction:"in"},{name:"outEdges",type:"directed",direction:"out"},{name:"inboundEdges",type:"mixed",direction:"in"},{name:"outboundEdges",type:"mixed",direction:"out"},{name:"directedEdges",type:"directed"},{name:"undirectedEdges",type:"undirected"}];function nt(t,e,n,r){var i=!1;for(var o in e)if(o!==r){var a=e[o];if(i=n(a.key,a.attributes,a.source.key,a.target.key,a.source.attributes,a.target.attributes,a.undirected),t&&i)return a.key}}function rt(t,e,n,r){var i,o,a,c=!1;for(var u in e)if(u!==r){i=e[u];do{if(o=i.source,a=i.target,c=n(i.key,i.attributes,o.key,a.key,o.attributes,a.attributes,i.undirected),t&&c)return i.key;i=i.next}while(void 0!==i)}}function it(t,e){var n,r=Object.keys(t),i=r.length,o=0;return new O((function(){do{if(n)n=n.next;else{if(o>=i)return{done:!0};var a=r[o++];if(a===e){n=void 0;continue}n=t[a]}}while(!n);return{done:!1,value:{edge:n.key,attributes:n.attributes,source:n.source.key,target:n.target.key,sourceAttributes:n.source.attributes,targetAttributes:n.target.attributes,undirected:n.undirected}}}))}function ot(t,e,n,r){var i=e[n];if(i){var o=i.source,a=i.target;return r(i.key,i.attributes,o.key,a.key,o.attributes,a.attributes,i.undirected)&&t?i.key:void 0}}function at(t,e,n,r){var i=e[n];if(i){var o=!1;do{if(o=r(i.key,i.attributes,i.source.key,i.target.key,i.source.attributes,i.target.attributes,i.undirected),t&&o)return i.key;i=i.next}while(void 0!==i)}}function ct(t,e){var n=t[e];return void 0!==n.next?new O((function(){if(!n)return{done:!0};var t={edge:n.key,attributes:n.attributes,source:n.source.key,target:n.target.key,sourceAttributes:n.source.attributes,targetAttributes:n.target.attributes,undirected:n.undirected};return n=n.next,{done:!1,value:t}})):O.of({edge:n.key,attributes:n.attributes,source:n.source.key,target:n.target.key,sourceAttributes:n.source.attributes,targetAttributes:n.target.attributes,undirected:n.undirected})}function ut(t,e){if(0===t.size)return[];if("mixed"===e||e===t.type)return"function"==typeof Array.from?Array.from(t._edges.keys()):K(t._edges.keys(),t._edges.size);for(var n,r,i="undirected"===e?t.undirectedSize:t.directedSize,o=new Array(i),a="undirected"===e,c=t._edges.values(),u=0;!0!==(n=c.next()).done;)(r=n.value).undirected===a&&(o[u++]=r.key);return o}function dt(t,e,n,r){if(0!==e.size)for(var i,o,a="mixed"!==n&&n!==e.type,c="undirected"===n,u=!1,d=e._edges.values();!0!==(i=d.next()).done;)if(o=i.value,!a||o.undirected===c){var s=o,h=s.key,p=s.attributes,f=s.source,l=s.target;if(u=r(h,p,f.key,l.key,f.attributes,l.attributes,o.undirected),t&&u)return h}}function st(t,e){if(0===t.size)return O.empty();var n="mixed"!==e&&e!==t.type,r="undirected"===e,i=t._edges.values();return new O((function(){for(var t,e;;){if((t=i.next()).done)return t;if(e=t.value,!n||e.undirected===r)break}return{value:{edge:e.key,attributes:e.attributes,source:e.source.key,target:e.target.key,sourceAttributes:e.source.attributes,targetAttributes:e.target.attributes,undirected:e.undirected},done:!1}}))}function ht(t,e,n,r,i,o){var a,c=e?rt:nt;if("undirected"!==n){if("out"!==r&&(a=c(t,i.in,o),t&&a))return a;if("in"!==r&&(a=c(t,i.out,o,r?void 0:i.key),t&&a))return a}if("directed"!==n&&(a=c(t,i.undirected,o),t&&a))return a}function pt(t,e,n,r){var i=[];return ht(!1,t,e,n,r,(function(t){i.push(t)})),i}function ft(t,e,n){var r=O.empty();return"undirected"!==t&&("out"!==e&&void 0!==n.in&&(r=tt(r,it(n.in))),"in"!==e&&void 0!==n.out&&(r=tt(r,it(n.out,e?void 0:n.key)))),"directed"!==t&&void 0!==n.undirected&&(r=tt(r,it(n.undirected))),r}function lt(t,e,n,r,i,o,a){var c,u=n?at:ot;if("undirected"!==e){if(void 0!==i.in&&"out"!==r&&(c=u(t,i.in,o,a),t&&c))return c;if(void 0!==i.out&&"in"!==r&&(r||i.key!==o)&&(c=u(t,i.out,o,a),t&&c))return c}if("directed"!==e&&void 0!==i.undirected&&(c=u(t,i.undirected,o,a),t&&c))return c}function gt(t,e,n,r,i){var o=[];return lt(!1,t,e,n,r,i,(function(t){o.push(t)})),o}function yt(t,e,n,r){var i=O.empty();return"undirected"!==t&&(void 0!==n.in&&"out"!==e&&r in n.in&&(i=tt(i,ct(n.in,r))),void 0!==n.out&&"in"!==e&&r in n.out&&(e||n.key!==r)&&(i=tt(i,ct(n.out,r)))),"directed"!==t&&void 0!==n.undirected&&r in n.undirected&&(i=tt(i,ct(n.undirected,r))),i}var wt=[{name:"neighbors",type:"mixed"},{name:"inNeighbors",type:"directed",direction:"in"},{name:"outNeighbors",type:"directed",direction:"out"},{name:"inboundNeighbors",type:"mixed",direction:"in"},{name:"outboundNeighbors",type:"mixed",direction:"out"},{name:"directedNeighbors",type:"directed"},{name:"undirectedNeighbors",type:"undirected"}];function vt(){this.A=null,this.B=null}function bt(t,e,n,r,i){for(var o in r){var a=r[o],c=a.source,u=a.target,d=c===n?u:c;if(!e||!e.has(d.key)){var s=i(d.key,d.attributes);if(t&&s)return d.key}}}function mt(t,e,n,r,i){if("mixed"!==e){if("undirected"===e)return bt(t,null,r,r.undirected,i);if("string"==typeof n)return bt(t,null,r,r[n],i)}var o,a=new vt;if("undirected"!==e){if("out"!==n){if(o=bt(t,null,r,r.in,i),t&&o)return o;a.wrap(r.in)}if("in"!==n){if(o=bt(t,a,r,r.out,i),t&&o)return o;a.wrap(r.out)}}if("directed"!==e&&(o=bt(t,a,r,r.undirected,i),t&&o))return o}function kt(t,e,n){var r=Object.keys(n),i=r.length,o=0;return new O((function(){var a=null;do{if(o>=i)return t&&t.wrap(n),{done:!0};var c=n[r[o++]],u=c.source,d=c.target;a=u===e?d:u,t&&t.has(a.key)&&(a=null)}while(null===a);return{done:!1,value:{neighbor:a.key,attributes:a.attributes}}}))}function _t(t,e){var n=e.name,r=e.type,i=e.direction;t.prototype[n]=function(t){if("mixed"!==r&&"mixed"!==this.type&&r!==this.type)return[];t=""+t;var e=this._nodes.get(t);if(void 0===e)throw new F("Graph.".concat(n,': could not find the "').concat(t,'" node in the graph.'));return function(t,e,n){if("mixed"!==t){if("undirected"===t)return Object.keys(n.undirected);if("string"==typeof e)return Object.keys(n[e])}var r=[];return mt(!1,t,e,n,(function(t){r.push(t)})),r}("mixed"===r?this.type:r,i,e)}}function Gt(t,e){var n=e.name,r=e.type,i=e.direction,o=n.slice(0,-1)+"Entries";t.prototype[o]=function(t){if("mixed"!==r&&"mixed"!==this.type&&r!==this.type)return O.empty();t=""+t;var e=this._nodes.get(t);if(void 0===e)throw new F("Graph.".concat(o,': could not find the "').concat(t,'" node in the graph.'));return function(t,e,n){if("mixed"!==t){if("undirected"===t)return kt(null,n,n.undirected);if("string"==typeof e)return kt(null,n,n[e])}var r=O.empty(),i=new vt;return"undirected"!==t&&("out"!==e&&(r=tt(r,kt(i,n,n.in))),"in"!==e&&(r=tt(r,kt(i,n,n.out)))),"directed"!==t&&(r=tt(r,kt(i,n,n.undirected))),r}("mixed"===r?this.type:r,i,e)}}function xt(t,e,n,r,i){for(var o,a,c,u,d,s,h,p=r._nodes.values(),f=r.type;!0!==(o=p.next()).done;){var l=!1;if(a=o.value,"undirected"!==f)for(c in u=a.out){d=u[c];do{if(s=d.target,l=!0,h=i(a.key,s.key,a.attributes,s.attributes,d.key,d.attributes,d.undirected),t&&h)return d;d=d.next}while(d)}if("directed"!==f)for(c in u=a.undirected)if(!(e&&a.key>c)){d=u[c];do{if((s=d.target).key!==c&&(s=d.source),l=!0,h=i(a.key,s.key,a.attributes,s.attributes,d.key,d.attributes,d.undirected),t&&h)return d;d=d.next}while(d)}if(n&&!l&&(h=i(a.key,null,a.attributes,null,null,null,null),t&&h))return null}}function Et(t){if(!s(t))throw new B('Graph.import: invalid serialized node. A serialized node should be a plain object with at least a "key" property.');if(!("key"in t))throw new B("Graph.import: serialized node is missing its key.");if("attributes"in t&&(!s(t.attributes)||null===t.attributes))throw new B("Graph.import: invalid attributes. Attributes should be a plain object, null or omitted.")}function At(t){if(!s(t))throw new B('Graph.import: invalid serialized edge. A serialized edge should be a plain object with at least a "source" & "target" property.');if(!("source"in t))throw new B("Graph.import: serialized edge is missing its source.");if(!("target"in t))throw new B("Graph.import: serialized edge is missing its target.");if("attributes"in t&&(!s(t.attributes)||null===t.attributes))throw new B("Graph.import: invalid attributes. Attributes should be a plain object, null or omitted.");if("undirected"in t&&"boolean"!=typeof t.undirected)throw new B("Graph.import: invalid undirectedness information. Undirected should be boolean or omitted.")}vt.prototype.wrap=function(t){null===this.A?this.A=t:null===this.B&&(this.B=t)},vt.prototype.has=function(t){return null!==this.A&&t in this.A||null!==this.B&&t in this.B};var Lt,St=(Lt=255&Math.floor(256*Math.random()),function(){return Lt++}),Dt=new Set(["directed","undirected","mixed"]),Ut=new Set(["domain","_events","_eventsCount","_maxListeners"]),Nt={allowSelfLoops:!0,multi:!1,type:"mixed"};function Ot(t,e,n){var r=new t.NodeDataClass(e,n);return t._nodes.set(e,r),t.emit("nodeAdded",{key:e,attributes:n}),r}function jt(t,e,n,r,i,o,a,c){if(!r&&"undirected"===t.type)throw new I("Graph.".concat(e,": you cannot add a directed edge to an undirected graph. Use the #.addEdge or #.addUndirectedEdge instead."));if(r&&"directed"===t.type)throw new I("Graph.".concat(e,": you cannot add an undirected edge to a directed graph. Use the #.addEdge or #.addDirectedEdge instead."));if(c&&!s(c))throw new B("Graph.".concat(e,': invalid attributes. Expecting an object but got "').concat(c,'"'));if(o=""+o,a=""+a,c=c||{},!t.allowSelfLoops&&o===a)throw new I("Graph.".concat(e,': source & target are the same ("').concat(o,"\"), thus creating a loop explicitly forbidden by this graph 'allowSelfLoops' option set to false."));var u=t._nodes.get(o),d=t._nodes.get(a);if(!u)throw new F("Graph.".concat(e,': source node "').concat(o,'" not found.'));if(!d)throw new F("Graph.".concat(e,': target node "').concat(a,'" not found.'));var h={key:null,undirected:r,source:o,target:a,attributes:c};if(n)i=t._edgeKeyGenerator();else if(i=""+i,t._edges.has(i))throw new I("Graph.".concat(e,': the "').concat(i,'" edge already exists in the graph.'));if(!t.multi&&(r?void 0!==u.undirected[a]:void 0!==u.out[a]))throw new I("Graph.".concat(e,': an edge linking "').concat(o,'" to "').concat(a,"\" already exists. If you really want to add multiple edges linking those nodes, you should create a multi graph by using the 'multi' option."));var p=new V(r,i,u,d,c);t._edges.set(i,p);var f=o===a;return r?(u.undirectedDegree++,d.undirectedDegree++,f&&(u.undirectedLoops++,t._undirectedSelfLoopCount++)):(u.outDegree++,d.inDegree++,f&&(u.directedLoops++,t._directedSelfLoopCount++)),t.multi?p.attachMulti():p.attach(),r?t._undirectedSize++:t._directedSize++,h.key=i,t.emit("edgeAdded",h),i}function Ct(t,e,n,r,i,o,a,c,d){if(!r&&"undirected"===t.type)throw new I("Graph.".concat(e,": you cannot merge/update a directed edge to an undirected graph. Use the #.mergeEdge/#.updateEdge or #.addUndirectedEdge instead."));if(r&&"directed"===t.type)throw new I("Graph.".concat(e,": you cannot merge/update an undirected edge to a directed graph. Use the #.mergeEdge/#.updateEdge or #.addDirectedEdge instead."));if(c)if(d){if("function"!=typeof c)throw new B("Graph.".concat(e,': invalid updater function. Expecting a function but got "').concat(c,'"'))}else if(!s(c))throw new B("Graph.".concat(e,': invalid attributes. Expecting an object but got "').concat(c,'"'));var h;if(o=""+o,a=""+a,d&&(h=c,c=void 0),!t.allowSelfLoops&&o===a)throw new I("Graph.".concat(e,': source & target are the same ("').concat(o,"\"), thus creating a loop explicitly forbidden by this graph 'allowSelfLoops' option set to false."));var p,f,l=t._nodes.get(o),g=t._nodes.get(a);if(!n&&(p=t._edges.get(i))){if(!(p.source.key===o&&p.target.key===a||r&&p.source.key===a&&p.target.key===o))throw new I("Graph.".concat(e,': inconsistency detected when attempting to merge the "').concat(i,'" edge with "').concat(o,'" source & "').concat(a,'" target vs. ("').concat(p.source.key,'", "').concat(p.target.key,'").'));f=p}if(f||t.multi||!l||(f=r?l.undirected[a]:l.out[a]),f){var y=[f.key,!1,!1,!1];if(d?!h:!c)return y;if(d){var w=f.attributes;f.attributes=h(w),t.emit("edgeAttributesUpdated",{type:"replace",key:f.key,attributes:f.attributes})}else u(f.attributes,c),t.emit("edgeAttributesUpdated",{type:"merge",key:f.key,attributes:f.attributes,data:c});return y}c=c||{},d&&h&&(c=h(c));var v={key:null,undirected:r,source:o,target:a,attributes:c};if(n)i=t._edgeKeyGenerator();else if(i=""+i,t._edges.has(i))throw new I("Graph.".concat(e,': the "').concat(i,'" edge already exists in the graph.'));var b=!1,m=!1;l||(l=Ot(t,o,{}),b=!0,o===a&&(g=l,m=!0)),g||(g=Ot(t,a,{}),m=!0),p=new V(r,i,l,g,c),t._edges.set(i,p);var k=o===a;return r?(l.undirectedDegree++,g.undirectedDegree++,k&&(l.undirectedLoops++,t._undirectedSelfLoopCount++)):(l.outDegree++,g.inDegree++,k&&(l.directedLoops++,t._directedSelfLoopCount++)),t.multi?p.attachMulti():p.attach(),r?t._undirectedSize++:t._directedSize++,v.key=i,t.emit("edgeAdded",v),[i,!0,b,m]}function Mt(t,e){t._edges.delete(e.key);var n=e.source,r=e.target,i=e.attributes,o=e.undirected,a=n===r;o?(n.undirectedDegree--,r.undirectedDegree--,a&&(n.undirectedLoops--,t._undirectedSelfLoopCount--)):(n.outDegree--,r.inDegree--,a&&(n.directedLoops--,t._directedSelfLoopCount--)),t.multi?e.detachMulti():e.detach(),o?t._undirectedSize--:t._directedSize--,t.emit("edgeDropped",{key:e.key,attributes:i,source:n.key,target:r.key,undirected:o})}var zt=function(n){function r(t){var e;if(e=n.call(this)||this,"boolean"!=typeof(t=u({},Nt,t)).multi)throw new B("Graph.constructor: invalid 'multi' option. Expecting a boolean but got \"".concat(t.multi,'".'));if(!Dt.has(t.type))throw new B('Graph.constructor: invalid \'type\' option. Should be one of "mixed", "directed" or "undirected" but got "'.concat(t.type,'".'));if("boolean"!=typeof t.allowSelfLoops)throw new B("Graph.constructor: invalid 'allowSelfLoops' option. Expecting a boolean but got \"".concat(t.allowSelfLoops,'".'));var r="mixed"===t.type?Y:"directed"===t.type?q:J;p(c(e),"NodeDataClass",r);var i="geid_"+St()+"_",o=0;return p(c(e),"_attributes",{}),p(c(e),"_nodes",new Map),p(c(e),"_edges",new Map),p(c(e),"_directedSize",0),p(c(e),"_undirectedSize",0),p(c(e),"_directedSelfLoopCount",0),p(c(e),"_undirectedSelfLoopCount",0),p(c(e),"_edgeKeyGenerator",(function(){var t;do{t=i+o++}while(e._edges.has(t));return t})),p(c(e),"_options",t),Ut.forEach((function(t){return p(c(e),t,e[t])})),f(c(e),"order",(function(){return e._nodes.size})),f(c(e),"size",(function(){return e._edges.size})),f(c(e),"directedSize",(function(){return e._directedSize})),f(c(e),"undirectedSize",(function(){return e._undirectedSize})),f(c(e),"selfLoopCount",(function(){return e._directedSelfLoopCount+e._undirectedSelfLoopCount})),f(c(e),"directedSelfLoopCount",(function(){return e._directedSelfLoopCount})),f(c(e),"undirectedSelfLoopCount",(function(){return e._undirectedSelfLoopCount})),f(c(e),"multi",e._options.multi),f(c(e),"type",e._options.type),f(c(e),"allowSelfLoops",e._options.allowSelfLoops),f(c(e),"implementation",(function(){return"graphology"})),e}e(r,n);var i=r.prototype;return i._resetInstanceCounters=function(){this._directedSize=0,this._undirectedSize=0,this._directedSelfLoopCount=0,this._undirectedSelfLoopCount=0},i.hasNode=function(t){return this._nodes.has(""+t)},i.hasDirectedEdge=function(t,e){if("undirected"===this.type)return!1;if(1===arguments.length){var n=""+t,r=this._edges.get(n);return!!r&&!r.undirected}if(2===arguments.length){t=""+t,e=""+e;var i=this._nodes.get(t);return!!i&&i.out.hasOwnProperty(e)}throw new B("Graph.hasDirectedEdge: invalid arity (".concat(arguments.length,", instead of 1 or 2). You can either ask for an edge id or for the existence of an edge between a source & a target."))},i.hasUndirectedEdge=function(t,e){if("directed"===this.type)return!1;if(1===arguments.length){var n=""+t,r=this._edges.get(n);return!!r&&r.undirected}if(2===arguments.length){t=""+t,e=""+e;var i=this._nodes.get(t);return!!i&&i.undirected.hasOwnProperty(e)}throw new B("Graph.hasDirectedEdge: invalid arity (".concat(arguments.length,", instead of 1 or 2). You can either ask for an edge id or for the existence of an edge between a source & a target."))},i.hasEdge=function(t,e){if(1===arguments.length){var n=""+t;return this._edges.has(n)}if(2===arguments.length){t=""+t,e=""+e;var r=this._nodes.get(t);return!!r&&(void 0!==r.out&&r.out.hasOwnProperty(e)||void 0!==r.undirected&&r.undirected.hasOwnProperty(e))}throw new B("Graph.hasEdge: invalid arity (".concat(arguments.length,", instead of 1 or 2). You can either ask for an edge id or for the existence of an edge between a source & a target."))},i.directedEdge=function(t,e){if("undirected"!==this.type){if(t=""+t,e=""+e,this.multi)throw new I("Graph.directedEdge: this method is irrelevant with multigraphs since there might be multiple edges between source & target. See #.directedEdges instead.");var n=this._nodes.get(t);if(!n)throw new F('Graph.directedEdge: could not find the "'.concat(t,'" source node in the graph.'));if(!this._nodes.has(e))throw new F('Graph.directedEdge: could not find the "'.concat(e,'" target node in the graph.'));var r=n.out&&n.out[e]||void 0;return r?r.key:void 0}},i.undirectedEdge=function(t,e){if("directed"!==this.type){if(t=""+t,e=""+e,this.multi)throw new I("Graph.undirectedEdge: this method is irrelevant with multigraphs since there might be multiple edges between source & target. See #.undirectedEdges instead.");var n=this._nodes.get(t);if(!n)throw new F('Graph.undirectedEdge: could not find the "'.concat(t,'" source node in the graph.'));if(!this._nodes.has(e))throw new F('Graph.undirectedEdge: could not find the "'.concat(e,'" target node in the graph.'));var r=n.undirected&&n.undirected[e]||void 0;return r?r.key:void 0}},i.edge=function(t,e){if(this.multi)throw new I("Graph.edge: this method is irrelevant with multigraphs since there might be multiple edges between source & target. See #.edges instead.");t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.edge: could not find the "'.concat(t,'" source node in the graph.'));if(!this._nodes.has(e))throw new F('Graph.edge: could not find the "'.concat(e,'" target node in the graph.'));var r=n.out&&n.out[e]||n.undirected&&n.undirected[e]||void 0;if(r)return r.key},i.areDirectedNeighbors=function(t,e){t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.areDirectedNeighbors: could not find the "'.concat(t,'" node in the graph.'));return"undirected"!==this.type&&(e in n.in||e in n.out)},i.areOutNeighbors=function(t,e){t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.areOutNeighbors: could not find the "'.concat(t,'" node in the graph.'));return"undirected"!==this.type&&e in n.out},i.areInNeighbors=function(t,e){t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.areInNeighbors: could not find the "'.concat(t,'" node in the graph.'));return"undirected"!==this.type&&e in n.in},i.areUndirectedNeighbors=function(t,e){t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.areUndirectedNeighbors: could not find the "'.concat(t,'" node in the graph.'));return"directed"!==this.type&&e in n.undirected},i.areNeighbors=function(t,e){t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.areNeighbors: could not find the "'.concat(t,'" node in the graph.'));return"undirected"!==this.type&&(e in n.in||e in n.out)||"directed"!==this.type&&e in n.undirected},i.areInboundNeighbors=function(t,e){t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.areInboundNeighbors: could not find the "'.concat(t,'" node in the graph.'));return"undirected"!==this.type&&e in n.in||"directed"!==this.type&&e in n.undirected},i.areOutboundNeighbors=function(t,e){t=""+t,e=""+e;var n=this._nodes.get(t);if(!n)throw new F('Graph.areOutboundNeighbors: could not find the "'.concat(t,'" node in the graph.'));return"undirected"!==this.type&&e in n.out||"directed"!==this.type&&e in n.undirected},i.inDegree=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.inDegree: could not find the "'.concat(t,'" node in the graph.'));return"undirected"===this.type?0:e.inDegree},i.outDegree=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.outDegree: could not find the "'.concat(t,'" node in the graph.'));return"undirected"===this.type?0:e.outDegree},i.directedDegree=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.directedDegree: could not find the "'.concat(t,'" node in the graph.'));return"undirected"===this.type?0:e.inDegree+e.outDegree},i.undirectedDegree=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.undirectedDegree: could not find the "'.concat(t,'" node in the graph.'));return"directed"===this.type?0:e.undirectedDegree},i.inboundDegree=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.inboundDegree: could not find the "'.concat(t,'" node in the graph.'));var n=0;return"directed"!==this.type&&(n+=e.undirectedDegree),"undirected"!==this.type&&(n+=e.inDegree),n},i.outboundDegree=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.outboundDegree: could not find the "'.concat(t,'" node in the graph.'));var n=0;return"directed"!==this.type&&(n+=e.undirectedDegree),"undirected"!==this.type&&(n+=e.outDegree),n},i.degree=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.degree: could not find the "'.concat(t,'" node in the graph.'));var n=0;return"directed"!==this.type&&(n+=e.undirectedDegree),"undirected"!==this.type&&(n+=e.inDegree+e.outDegree),n},i.inDegreeWithoutSelfLoops=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.inDegreeWithoutSelfLoops: could not find the "'.concat(t,'" node in the graph.'));return"undirected"===this.type?0:e.inDegree-e.directedLoops},i.outDegreeWithoutSelfLoops=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.outDegreeWithoutSelfLoops: could not find the "'.concat(t,'" node in the graph.'));return"undirected"===this.type?0:e.outDegree-e.directedLoops},i.directedDegreeWithoutSelfLoops=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.directedDegreeWithoutSelfLoops: could not find the "'.concat(t,'" node in the graph.'));return"undirected"===this.type?0:e.inDegree+e.outDegree-2*e.directedLoops},i.undirectedDegreeWithoutSelfLoops=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.undirectedDegreeWithoutSelfLoops: could not find the "'.concat(t,'" node in the graph.'));return"directed"===this.type?0:e.undirectedDegree-2*e.undirectedLoops},i.inboundDegreeWithoutSelfLoops=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.inboundDegreeWithoutSelfLoops: could not find the "'.concat(t,'" node in the graph.'));var n=0,r=0;return"directed"!==this.type&&(n+=e.undirectedDegree,r+=2*e.undirectedLoops),"undirected"!==this.type&&(n+=e.inDegree,r+=e.directedLoops),n-r},i.outboundDegreeWithoutSelfLoops=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.outboundDegreeWithoutSelfLoops: could not find the "'.concat(t,'" node in the graph.'));var n=0,r=0;return"directed"!==this.type&&(n+=e.undirectedDegree,r+=2*e.undirectedLoops),"undirected"!==this.type&&(n+=e.outDegree,r+=e.directedLoops),n-r},i.degreeWithoutSelfLoops=function(t){t=""+t;var e=this._nodes.get(t);if(!e)throw new F('Graph.degreeWithoutSelfLoops: could not find the "'.concat(t,'" node in the graph.'));var n=0,r=0;return"directed"!==this.type&&(n+=e.undirectedDegree,r+=2*e.undirectedLoops),"undirected"!==this.type&&(n+=e.inDegree+e.outDegree,r+=2*e.directedLoops),n-r},i.source=function(t){t=""+t;var e=this._edges.get(t);if(!e)throw new F('Graph.source: could not find the "'.concat(t,'" edge in the graph.'));return e.source.key},i.target=function(t){t=""+t;var e=this._edges.get(t);if(!e)throw new F('Graph.target: could not find the "'.concat(t,'" edge in the graph.'));return e.target.key},i.extremities=function(t){t=""+t;var e=this._edges.get(t);if(!e)throw new F('Graph.extremities: could not find the "'.concat(t,'" edge in the graph.'));return[e.source.key,e.target.key]},i.opposite=function(t,e){t=""+t,e=""+e;var n=this._edges.get(e);if(!n)throw new F('Graph.opposite: could not find the "'.concat(e,'" edge in the graph.'));var r=n.source.key,i=n.target.key;if(t===r)return i;if(t===i)return r;throw new F('Graph.opposite: the "'.concat(t,'" node is not attached to the "').concat(e,'" edge (').concat(r,", ").concat(i,")."))},i.hasExtremity=function(t,e){t=""+t,e=""+e;var n=this._edges.get(t);if(!n)throw new F('Graph.hasExtremity: could not find the "'.concat(t,'" edge in the graph.'));return n.source.key===e||n.target.key===e},i.isUndirected=function(t){t=""+t;var e=this._edges.get(t);if(!e)throw new F('Graph.isUndirected: could not find the "'.concat(t,'" edge in the graph.'));return e.undirected},i.isDirected=function(t){t=""+t;var e=this._edges.get(t);if(!e)throw new F('Graph.isDirected: could not find the "'.concat(t,'" edge in the graph.'));return!e.undirected},i.isSelfLoop=function(t){t=""+t;var e=this._edges.get(t);if(!e)throw new F('Graph.isSelfLoop: could not find the "'.concat(t,'" edge in the graph.'));return e.source===e.target},i.addNode=function(t,e){var n=function(t,e,n){if(n&&!s(n))throw new B('Graph.addNode: invalid attributes. Expecting an object but got "'.concat(n,'"'));if(e=""+e,n=n||{},t._nodes.has(e))throw new I('Graph.addNode: the "'.concat(e,'" node already exist in the graph.'));var r=new t.NodeDataClass(e,n);return t._nodes.set(e,r),t.emit("nodeAdded",{key:e,attributes:n}),r}(this,t,e);return n.key},i.mergeNode=function(t,e){if(e&&!s(e))throw new B('Graph.mergeNode: invalid attributes. Expecting an object but got "'.concat(e,'"'));t=""+t,e=e||{};var n=this._nodes.get(t);return n?(e&&(u(n.attributes,e),this.emit("nodeAttributesUpdated",{type:"merge",key:t,attributes:n.attributes,data:e})),[t,!1]):(n=new this.NodeDataClass(t,e),this._nodes.set(t,n),this.emit("nodeAdded",{key:t,attributes:e}),[t,!0])},i.updateNode=function(t,e){if(e&&"function"!=typeof e)throw new B('Graph.updateNode: invalid updater function. Expecting a function but got "'.concat(e,'"'));t=""+t;var n=this._nodes.get(t);if(n){if(e){var r=n.attributes;n.attributes=e(r),this.emit("nodeAttributesUpdated",{type:"replace",key:t,attributes:n.attributes})}return[t,!1]}var i=e?e({}):{};return n=new this.NodeDataClass(t,i),this._nodes.set(t,n),this.emit("nodeAdded",{key:t,attributes:i}),[t,!0]},i.dropNode=function(t){t=""+t;var e,n=this._nodes.get(t);if(!n)throw new F('Graph.dropNode: could not find the "'.concat(t,'" node in the graph.'));if("undirected"!==this.type){for(var r in n.out){e=n.out[r];do{Mt(this,e),e=e.next}while(e)}for(var i in n.in){e=n.in[i];do{Mt(this,e),e=e.next}while(e)}}if("directed"!==this.type)for(var o in n.undirected){e=n.undirected[o];do{Mt(this,e),e=e.next}while(e)}this._nodes.delete(t),this.emit("nodeDropped",{key:t,attributes:n.attributes})},i.dropEdge=function(t){var e;if(arguments.length>1){var n=""+arguments[0],r=""+arguments[1];if(!(e=d(this,n,r,this.type)))throw new F('Graph.dropEdge: could not find the "'.concat(n,'" -> "').concat(r,'" edge in the graph.'))}else if(t=""+t,!(e=this._edges.get(t)))throw new F('Graph.dropEdge: could not find the "'.concat(t,'" edge in the graph.'));return Mt(this,e),this},i.dropDirectedEdge=function(t,e){if(arguments.length<2)throw new I("Graph.dropDirectedEdge: it does not make sense to try and drop a directed edge by key. What if the edge with this key is undirected? Use #.dropEdge for this purpose instead.");if(this.multi)throw new I("Graph.dropDirectedEdge: cannot use a {source,target} combo when dropping an edge in a MultiGraph since we cannot infer the one you want to delete as there could be multiple ones.");var n=d(this,t=""+t,e=""+e,"directed");if(!n)throw new F('Graph.dropDirectedEdge: could not find a "'.concat(t,'" -> "').concat(e,'" edge in the graph.'));return Mt(this,n),this},i.dropUndirectedEdge=function(t,e){if(arguments.length<2)throw new I("Graph.dropUndirectedEdge: it does not make sense to drop a directed edge by key. What if the edge with this key is undirected? Use #.dropEdge for this purpose instead.");if(this.multi)throw new I("Graph.dropUndirectedEdge: cannot use a {source,target} combo when dropping an edge in a MultiGraph since we cannot infer the one you want to delete as there could be multiple ones.");var n=d(this,t,e,"undirected");if(!n)throw new F('Graph.dropUndirectedEdge: could not find a "'.concat(t,'" -> "').concat(e,'" edge in the graph.'));return Mt(this,n),this},i.clear=function(){this._edges.clear(),this._nodes.clear(),this._resetInstanceCounters(),this.emit("cleared")},i.clearEdges=function(){for(var t,e=this._nodes.values();!0!==(t=e.next()).done;)t.value.clear();this._edges.clear(),this._resetInstanceCounters(),this.emit("edgesCleared")},i.getAttribute=function(t){return this._attributes[t]},i.getAttributes=function(){return this._attributes},i.hasAttribute=function(t){return this._attributes.hasOwnProperty(t)},i.setAttribute=function(t,e){return this._attributes[t]=e,this.emit("attributesUpdated",{type:"set",attributes:this._attributes,name:t}),this},i.updateAttribute=function(t,e){if("function"!=typeof e)throw new B("Graph.updateAttribute: updater should be a function.");var n=this._attributes[t];return this._attributes[t]=e(n),this.emit("attributesUpdated",{type:"set",attributes:this._attributes,name:t}),this},i.removeAttribute=function(t){return delete this._attributes[t],this.emit("attributesUpdated",{type:"remove",attributes:this._attributes,name:t}),this},i.replaceAttributes=function(t){if(!s(t))throw new B("Graph.replaceAttributes: provided attributes are not a plain object.");return this._attributes=t,this.emit("attributesUpdated",{type:"replace",attributes:this._attributes}),this},i.mergeAttributes=function(t){if(!s(t))throw new B("Graph.mergeAttributes: provided attributes are not a plain object.");return u(this._attributes,t),this.emit("attributesUpdated",{type:"merge",attributes:this._attributes,data:t}),this},i.updateAttributes=function(t){if("function"!=typeof t)throw new B("Graph.updateAttributes: provided updater is not a function.");return this._attributes=t(this._attributes),this.emit("attributesUpdated",{type:"update",attributes:this._attributes}),this},i.updateEachNodeAttributes=function(t,e){if("function"!=typeof t)throw new B("Graph.updateEachNodeAttributes: expecting an updater function.");if(e&&!l(e))throw new B("Graph.updateEachNodeAttributes: invalid hints. Expecting an object having the following shape: {attributes?: [string]}");for(var n,r,i=this._nodes.values();!0!==(n=i.next()).done;)(r=n.value).attributes=t(r.key,r.attributes);this.emit("eachNodeAttributesUpdated",{hints:e||null})},i.updateEachEdgeAttributes=function(t,e){if("function"!=typeof t)throw new B("Graph.updateEachEdgeAttributes: expecting an updater function.");if(e&&!l(e))throw new B("Graph.updateEachEdgeAttributes: invalid hints. Expecting an object having the following shape: {attributes?: [string]}");for(var n,r,i,o,a=this._edges.values();!0!==(n=a.next()).done;)i=(r=n.value).source,o=r.target,r.attributes=t(r.key,r.attributes,i.key,o.key,i.attributes,o.attributes,r.undirected);this.emit("eachEdgeAttributesUpdated",{hints:e||null})},i.forEachAdjacencyEntry=function(t){if("function"!=typeof t)throw new B("Graph.forEachAdjacencyEntry: expecting a callback.");xt(!1,!1,!1,this,t)},i.forEachAdjacencyEntryWithOrphans=function(t){if("function"!=typeof t)throw new B("Graph.forEachAdjacencyEntryWithOrphans: expecting a callback.");xt(!1,!1,!0,this,t)},i.forEachAssymetricAdjacencyEntry=function(t){if("function"!=typeof t)throw new B("Graph.forEachAssymetricAdjacencyEntry: expecting a callback.");xt(!1,!0,!1,this,t)},i.forEachAssymetricAdjacencyEntryWithOrphans=function(t){if("function"!=typeof t)throw new B("Graph.forEachAssymetricAdjacencyEntryWithOrphans: expecting a callback.");xt(!1,!0,!0,this,t)},i.nodes=function(){return"function"==typeof Array.from?Array.from(this._nodes.keys()):K(this._nodes.keys(),this._nodes.size)},i.forEachNode=function(t){if("function"!=typeof t)throw new B("Graph.forEachNode: expecting a callback.");for(var e,n,r=this._nodes.values();!0!==(e=r.next()).done;)t((n=e.value).key,n.attributes)},i.findNode=function(t){if("function"!=typeof t)throw new B("Graph.findNode: expecting a callback.");for(var e,n,r=this._nodes.values();!0!==(e=r.next()).done;)if(t((n=e.value).key,n.attributes))return n.key},i.mapNodes=function(t){if("function"!=typeof t)throw new B("Graph.mapNode: expecting a callback.");for(var e,n,r=this._nodes.values(),i=new Array(this.order),o=0;!0!==(e=r.next()).done;)n=e.value,i[o++]=t(n.key,n.attributes);return i},i.someNode=function(t){if("function"!=typeof t)throw new B("Graph.someNode: expecting a callback.");for(var e,n,r=this._nodes.values();!0!==(e=r.next()).done;)if(t((n=e.value).key,n.attributes))return!0;return!1},i.everyNode=function(t){if("function"!=typeof t)throw new B("Graph.everyNode: expecting a callback.");for(var e,n,r=this._nodes.values();!0!==(e=r.next()).done;)if(!t((n=e.value).key,n.attributes))return!1;return!0},i.filterNodes=function(t){if("function"!=typeof t)throw new B("Graph.filterNodes: expecting a callback.");for(var e,n,r=this._nodes.values(),i=[];!0!==(e=r.next()).done;)t((n=e.value).key,n.attributes)&&i.push(n.key);return i},i.reduceNodes=function(t,e){if("function"!=typeof t)throw new B("Graph.reduceNodes: expecting a callback.");if(arguments.length<2)throw new B("Graph.reduceNodes: missing initial value. You must provide it because the callback takes more than one argument and we cannot infer the initial value from the first iteration, as you could with a simple array.");for(var n,r,i=e,o=this._nodes.values();!0!==(n=o.next()).done;)i=t(i,(r=n.value).key,r.attributes);return i},i.nodeEntries=function(){var t=this._nodes.values();return new O((function(){var e=t.next();if(e.done)return e;var n=e.value;return{value:{node:n.key,attributes:n.attributes},done:!1}}))},i.export=function(){var t=this,e=new Array(this._nodes.size),n=0;this._nodes.forEach((function(t,r){e[n++]=function(t,e){var n={key:t};return h(e.attributes)||(n.attributes=u({},e.attributes)),n}(r,t)}));var r=new Array(this._edges.size);return n=0,this._edges.forEach((function(e,i){r[n++]=function(t,e,n){var r={key:e,source:n.source.key,target:n.target.key};return h(n.attributes)||(r.attributes=u({},n.attributes)),"mixed"===t&&n.undirected&&(r.undirected=!0),r}(t.type,i,e)})),{options:{type:this.type,multi:this.multi,allowSelfLoops:this.allowSelfLoops},attributes:this.getAttributes(),nodes:e,edges:r}},i.import=function(t){var e,n,i,o,a,c=this,u=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(t instanceof r)return t.forEachNode((function(t,e){u?c.mergeNode(t,e):c.addNode(t,e)})),t.forEachEdge((function(t,e,n,r,i,o,a){u?a?c.mergeUndirectedEdgeWithKey(t,n,r,e):c.mergeDirectedEdgeWithKey(t,n,r,e):a?c.addUndirectedEdgeWithKey(t,n,r,e):c.addDirectedEdgeWithKey(t,n,r,e)})),this;if(!s(t))throw new B("Graph.import: invalid argument. Expecting a serialized graph or, alternatively, a Graph instance.");if(t.attributes){if(!s(t.attributes))throw new B("Graph.import: invalid attributes. Expecting a plain object.");u?this.mergeAttributes(t.attributes):this.replaceAttributes(t.attributes)}if(t.nodes){if(i=t.nodes,!Array.isArray(i))throw new B("Graph.import: invalid nodes. Expecting an array.");for(e=0,n=i.length;e<n;e++){Et(o=i[e]);var d=o,h=d.key,p=d.attributes;u?this.mergeNode(h,p):this.addNode(h,p)}}if(t.edges){var f=!1;if("undirected"===this.type&&(f=!0),i=t.edges,!Array.isArray(i))throw new B("Graph.import: invalid edges. Expecting an array.");for(e=0,n=i.length;e<n;e++){At(a=i[e]);var l=a,g=l.source,y=l.target,w=l.attributes,v=l.undirected,b=void 0===v?f:v;"key"in a?(u?b?this.mergeUndirectedEdgeWithKey:this.mergeDirectedEdgeWithKey:b?this.addUndirectedEdgeWithKey:this.addDirectedEdgeWithKey).call(this,a.key,g,y,w):(u?b?this.mergeUndirectedEdge:this.mergeDirectedEdge:b?this.addUndirectedEdge:this.addDirectedEdge).call(this,g,y,w)}}return this},i.nullCopy=function(t){var e=new r(u({},this._options,t));return e.replaceAttributes(u({},this.getAttributes())),e},i.emptyCopy=function(t){var e=this.nullCopy(t);return this._nodes.forEach((function(t,n){var r=u({},t.attributes);t=new e.NodeDataClass(n,r),e._nodes.set(n,t)})),e},i.copy=function(t){if("string"==typeof(t=t||{}).type&&t.type!==this.type&&"mixed"!==t.type)throw new I('Graph.copy: cannot create an incompatible copy from "'.concat(this.type,'" type to "').concat(t.type,'" because this would mean losing information about the current graph.'));if("boolean"==typeof t.multi&&t.multi!==this.multi&&!0!==t.multi)throw new I("Graph.copy: cannot create an incompatible copy by downgrading a multi graph to a simple one because this would mean losing information about the current graph.");if("boolean"==typeof t.allowSelfLoops&&t.allowSelfLoops!==this.allowSelfLoops&&!0!==t.allowSelfLoops)throw new I("Graph.copy: cannot create an incompatible copy from a graph allowing self loops to one that does not because this would mean losing information about the current graph.");for(var e,n,r=this.emptyCopy(t),i=this._edges.values();!0!==(e=i.next()).done;)jt(r,"copy",!1,(n=e.value).undirected,n.key,n.source.key,n.target.key,u({},n.attributes));return r},i.toJSON=function(){return this.export()},i.toString=function(){return"[object Graph]"},i.inspect=function(){var e=this,n={};this._nodes.forEach((function(t,e){n[e]=t.attributes}));var r={},i={};this._edges.forEach((function(t,n){var o,a=t.undirected?"--":"->",c="",u=t.source.key,d=t.target.key;t.undirected&&u>d&&(o=u,u=d,d=o);var s="(".concat(u,")").concat(a,"(").concat(d,")");n.startsWith("geid_")?e.multi&&(void 0===i[s]?i[s]=0:i[s]++,c+="".concat(i[s],". ")):c+="[".concat(n,"]: "),r[c+=s]=t.attributes}));var o={};for(var a in this)this.hasOwnProperty(a)&&!Ut.has(a)&&"function"!=typeof this[a]&&"symbol"!==t(a)&&(o[a]=this[a]);return o.attributes=this._attributes,o.nodes=n,o.edges=r,p(o,"constructor",this.constructor),o},r}(y.exports.EventEmitter);"undefined"!=typeof Symbol&&(zt.prototype[Symbol.for("nodejs.util.inspect.custom")]=zt.prototype.inspect),[{name:function(t){return"".concat(t,"Edge")},generateKey:!0},{name:function(t){return"".concat(t,"DirectedEdge")},generateKey:!0,type:"directed"},{name:function(t){return"".concat(t,"UndirectedEdge")},generateKey:!0,type:"undirected"},{name:function(t){return"".concat(t,"EdgeWithKey")}},{name:function(t){return"".concat(t,"DirectedEdgeWithKey")},type:"directed"},{name:function(t){return"".concat(t,"UndirectedEdgeWithKey")},type:"undirected"}].forEach((function(t){["add","merge","update"].forEach((function(e){var n=t.name(e),r="add"===e?jt:Ct;t.generateKey?zt.prototype[n]=function(i,o,a){return r(this,n,!0,"undirected"===(t.type||this.type),null,i,o,a,"update"===e)}:zt.prototype[n]=function(i,o,a,c){return r(this,n,!1,"undirected"===(t.type||this.type),i,o,a,c,"update"===e)}}))})),function(t){Q.forEach((function(e){var n=e.name,r=e.attacher;r(t,n("Node"),0),r(t,n("Source"),1),r(t,n("Target"),2),r(t,n("Opposite"),3)}))}(zt),function(t){X.forEach((function(e){var n=e.name,r=e.attacher;r(t,n("Edge"),"mixed"),r(t,n("DirectedEdge"),"directed"),r(t,n("UndirectedEdge"),"undirected")}))}(zt),function(t){et.forEach((function(e){!function(t,e){var n=e.name,r=e.type,i=e.direction;t.prototype[n]=function(t,e){if("mixed"!==r&&"mixed"!==this.type&&r!==this.type)return[];if(!arguments.length)return ut(this,r);if(1===arguments.length){t=""+t;var o=this._nodes.get(t);if(void 0===o)throw new F("Graph.".concat(n,': could not find the "').concat(t,'" node in the graph.'));return pt(this.multi,"mixed"===r?this.type:r,i,o)}if(2===arguments.length){t=""+t,e=""+e;var a=this._nodes.get(t);if(!a)throw new F("Graph.".concat(n,':  could not find the "').concat(t,'" source node in the graph.'));if(!this._nodes.has(e))throw new F("Graph.".concat(n,':  could not find the "').concat(e,'" target node in the graph.'));return gt(r,this.multi,i,a,e)}throw new B("Graph.".concat(n,": too many arguments (expecting 0, 1 or 2 and got ").concat(arguments.length,")."))}}(t,e),function(t,e){var n=e.name,r=e.type,i=e.direction,o="forEach"+n[0].toUpperCase()+n.slice(1,-1);t.prototype[o]=function(t,e,n){if("mixed"===r||"mixed"===this.type||r===this.type){if(1===arguments.length)return dt(!1,this,r,n=t);if(2===arguments.length){t=""+t,n=e;var a=this._nodes.get(t);if(void 0===a)throw new F("Graph.".concat(o,': could not find the "').concat(t,'" node in the graph.'));return ht(!1,this.multi,"mixed"===r?this.type:r,i,a,n)}if(3===arguments.length){t=""+t,e=""+e;var c=this._nodes.get(t);if(!c)throw new F("Graph.".concat(o,':  could not find the "').concat(t,'" source node in the graph.'));if(!this._nodes.has(e))throw new F("Graph.".concat(o,':  could not find the "').concat(e,'" target node in the graph.'));return lt(!1,r,this.multi,i,c,e,n)}throw new B("Graph.".concat(o,": too many arguments (expecting 1, 2 or 3 and got ").concat(arguments.length,")."))}};var a="map"+n[0].toUpperCase()+n.slice(1);t.prototype[a]=function(){var t,e=Array.prototype.slice.call(arguments),n=e.pop();if(0===e.length){var i=0;"directed"!==r&&(i+=this.undirectedSize),"undirected"!==r&&(i+=this.directedSize),t=new Array(i);var a=0;e.push((function(e,r,i,o,c,u,d){t[a++]=n(e,r,i,o,c,u,d)}))}else t=[],e.push((function(e,r,i,o,a,c,u){t.push(n(e,r,i,o,a,c,u))}));return this[o].apply(this,e),t};var c="filter"+n[0].toUpperCase()+n.slice(1);t.prototype[c]=function(){var t=Array.prototype.slice.call(arguments),e=t.pop(),n=[];return t.push((function(t,r,i,o,a,c,u){e(t,r,i,o,a,c,u)&&n.push(t)})),this[o].apply(this,t),n};var u="reduce"+n[0].toUpperCase()+n.slice(1);t.prototype[u]=function(){var t,e,n=Array.prototype.slice.call(arguments);if(n.length<2||n.length>4)throw new B("Graph.".concat(u,": invalid number of arguments (expecting 2, 3 or 4 and got ").concat(n.length,")."));if("function"==typeof n[n.length-1]&&"function"!=typeof n[n.length-2])throw new B("Graph.".concat(u,": missing initial value. You must provide it because the callback takes more than one argument and we cannot infer the initial value from the first iteration, as you could with a simple array."));2===n.length?(t=n[0],e=n[1],n=[]):3===n.length?(t=n[1],e=n[2],n=[n[0]]):4===n.length&&(t=n[2],e=n[3],n=[n[0],n[1]]);var r=e;return n.push((function(e,n,i,o,a,c,u){r=t(r,e,n,i,o,a,c,u)})),this[o].apply(this,n),r}}(t,e),function(t,e){var n=e.name,r=e.type,i=e.direction,o="find"+n[0].toUpperCase()+n.slice(1,-1);t.prototype[o]=function(t,e,n){if("mixed"!==r&&"mixed"!==this.type&&r!==this.type)return!1;if(1===arguments.length)return dt(!0,this,r,n=t);if(2===arguments.length){t=""+t,n=e;var a=this._nodes.get(t);if(void 0===a)throw new F("Graph.".concat(o,': could not find the "').concat(t,'" node in the graph.'));return ht(!0,this.multi,"mixed"===r?this.type:r,i,a,n)}if(3===arguments.length){t=""+t,e=""+e;var c=this._nodes.get(t);if(!c)throw new F("Graph.".concat(o,':  could not find the "').concat(t,'" source node in the graph.'));if(!this._nodes.has(e))throw new F("Graph.".concat(o,':  could not find the "').concat(e,'" target node in the graph.'));return lt(!0,r,this.multi,i,c,e,n)}throw new B("Graph.".concat(o,": too many arguments (expecting 1, 2 or 3 and got ").concat(arguments.length,")."))};var a="some"+n[0].toUpperCase()+n.slice(1,-1);t.prototype[a]=function(){var t=Array.prototype.slice.call(arguments),e=t.pop();return t.push((function(t,n,r,i,o,a,c){return e(t,n,r,i,o,a,c)})),!!this[o].apply(this,t)};var c="every"+n[0].toUpperCase()+n.slice(1,-1);t.prototype[c]=function(){var t=Array.prototype.slice.call(arguments),e=t.pop();return t.push((function(t,n,r,i,o,a,c){return!e(t,n,r,i,o,a,c)})),!this[o].apply(this,t)}}(t,e),function(t,e){var n=e.name,r=e.type,i=e.direction,o=n.slice(0,-1)+"Entries";t.prototype[o]=function(t,e){if("mixed"!==r&&"mixed"!==this.type&&r!==this.type)return O.empty();if(!arguments.length)return st(this,r);if(1===arguments.length){t=""+t;var n=this._nodes.get(t);if(!n)throw new F("Graph.".concat(o,': could not find the "').concat(t,'" node in the graph.'));return ft(r,i,n)}if(2===arguments.length){t=""+t,e=""+e;var a=this._nodes.get(t);if(!a)throw new F("Graph.".concat(o,':  could not find the "').concat(t,'" source node in the graph.'));if(!this._nodes.has(e))throw new F("Graph.".concat(o,':  could not find the "').concat(e,'" target node in the graph.'));return yt(r,i,a,e)}throw new B("Graph.".concat(o,": too many arguments (expecting 0, 1 or 2 and got ").concat(arguments.length,")."))}}(t,e)}))}(zt),function(t){wt.forEach((function(e){_t(t,e),function(t,e){var n=e.name,r=e.type,i=e.direction,o="forEach"+n[0].toUpperCase()+n.slice(1,-1);t.prototype[o]=function(t,e){if("mixed"===r||"mixed"===this.type||r===this.type){t=""+t;var n=this._nodes.get(t);if(void 0===n)throw new F("Graph.".concat(o,': could not find the "').concat(t,'" node in the graph.'));mt(!1,"mixed"===r?this.type:r,i,n,e)}};var a="map"+n[0].toUpperCase()+n.slice(1);t.prototype[a]=function(t,e){var n=[];return this[o](t,(function(t,r){n.push(e(t,r))})),n};var c="filter"+n[0].toUpperCase()+n.slice(1);t.prototype[c]=function(t,e){var n=[];return this[o](t,(function(t,r){e(t,r)&&n.push(t)})),n};var u="reduce"+n[0].toUpperCase()+n.slice(1);t.prototype[u]=function(t,e,n){if(arguments.length<3)throw new B("Graph.".concat(u,": missing initial value. You must provide it because the callback takes more than one argument and we cannot infer the initial value from the first iteration, as you could with a simple array."));var r=n;return this[o](t,(function(t,n){r=e(r,t,n)})),r}}(t,e),function(t,e){var n=e.name,r=e.type,i=e.direction,o=n[0].toUpperCase()+n.slice(1,-1),a="find"+o;t.prototype[a]=function(t,e){if("mixed"===r||"mixed"===this.type||r===this.type){t=""+t;var n=this._nodes.get(t);if(void 0===n)throw new F("Graph.".concat(a,': could not find the "').concat(t,'" node in the graph.'));return mt(!0,"mixed"===r?this.type:r,i,n,e)}};var c="some"+o;t.prototype[c]=function(t,e){return!!this[a](t,e)};var u="every"+o;t.prototype[u]=function(t,e){return!this[a](t,(function(t,n){return!e(t,n)}))}}(t,e),Gt(t,e)}))}(zt);var Wt=function(t){function n(e){var n=u({type:"directed"},e);if("multi"in n&&!1!==n.multi)throw new B("DirectedGraph.from: inconsistent indication that the graph should be multi in given options!");if("directed"!==n.type)throw new B('DirectedGraph.from: inconsistent "'+n.type+'" type in given options!');return t.call(this,n)||this}return e(n,t),n}(zt),Pt=function(t){function n(e){var n=u({type:"undirected"},e);if("multi"in n&&!1!==n.multi)throw new B("UndirectedGraph.from: inconsistent indication that the graph should be multi in given options!");if("undirected"!==n.type)throw new B('UndirectedGraph.from: inconsistent "'+n.type+'" type in given options!');return t.call(this,n)||this}return e(n,t),n}(zt),Rt=function(t){function n(e){var n=u({multi:!0},e);if("multi"in n&&!0!==n.multi)throw new B("MultiGraph.from: inconsistent indication that the graph should be simple in given options!");return t.call(this,n)||this}return e(n,t),n}(zt),Kt=function(t){function n(e){var n=u({type:"directed",multi:!0},e);if("multi"in n&&!0!==n.multi)throw new B("MultiDirectedGraph.from: inconsistent indication that the graph should be simple in given options!");if("directed"!==n.type)throw new B('MultiDirectedGraph.from: inconsistent "'+n.type+'" type in given options!');return t.call(this,n)||this}return e(n,t),n}(zt),Tt=function(t){function n(e){var n=u({type:"undirected",multi:!0},e);if("multi"in n&&!0!==n.multi)throw new B("MultiUndirectedGraph.from: inconsistent indication that the graph should be simple in given options!");if("undirected"!==n.type)throw new B('MultiUndirectedGraph.from: inconsistent "'+n.type+'" type in given options!');return t.call(this,n)||this}return e(n,t),n}(zt);function Bt(t){t.from=function(e,n){var r=u({},e.options,n),i=new t(r);return i.import(e),i}}return Bt(zt),Bt(Wt),Bt(Pt),Bt(Rt),Bt(Kt),Bt(Tt),zt.Graph=zt,zt.DirectedGraph=Wt,zt.UndirectedGraph=Pt,zt.MultiGraph=Rt,zt.MultiDirectedGraph=Kt,zt.MultiUndirectedGraph=Tt,zt.InvalidArgumentsGraphError=B,zt.NotFoundGraphError=F,zt.UsageGraphError=I,zt}));
+//# sourceMappingURL=graphology.umd.min.js.map
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// 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] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
+/******/ 	// the startup function
+/******/ 	__webpack_require__.x = () => {
+/******/ 		// Load entry module and return exports
+/******/ 		// This entry module depends on other loaded chunks and execution need to be delayed
+/******/ 		var __webpack_exports__ = __webpack_require__.O(undefined, ["vendors-node_modules_datagrok-libraries_math_src_webGPU_sparse-matrix_webGPU-sparse-matrix_js-07693f"], () => (__webpack_require__("./node_modules/@datagrok-libraries/ml/src/MCL/mcl-worker.js")))
+/******/ 		__webpack_exports__ = __webpack_require__.O(__webpack_exports__);
+/******/ 		return __webpack_exports__;
+/******/ 	};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/chunk loaded */
+/******/ 	(() => {
+/******/ 		var deferred = [];
+/******/ 		__webpack_require__.O = (result, chunkIds, fn, priority) => {
+/******/ 			if(chunkIds) {
+/******/ 				priority = priority || 0;
+/******/ 				for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
+/******/ 				deferred[i] = [chunkIds, fn, priority];
+/******/ 				return;
+/******/ 			}
+/******/ 			var notFulfilled = Infinity;
+/******/ 			for (var i = 0; i < deferred.length; i++) {
+/******/ 				var [chunkIds, fn, priority] = deferred[i];
+/******/ 				var fulfilled = true;
+/******/ 				for (var j = 0; j < chunkIds.length; j++) {
+/******/ 					if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
+/******/ 						chunkIds.splice(j--, 1);
+/******/ 					} else {
+/******/ 						fulfilled = false;
+/******/ 						if(priority < notFulfilled) notFulfilled = priority;
+/******/ 					}
+/******/ 				}
+/******/ 				if(fulfilled) {
+/******/ 					deferred.splice(i--, 1)
+/******/ 					var r = fn();
+/******/ 					if (r !== undefined) result = r;
+/******/ 				}
+/******/ 			}
+/******/ 			return result;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* 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/ensure chunk */
+/******/ 	(() => {
+/******/ 		__webpack_require__.f = {};
+/******/ 		// This file contains only the entry chunk.
+/******/ 		// The chunk loading function for additional chunks
+/******/ 		__webpack_require__.e = (chunkId) => {
+/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
+/******/ 				__webpack_require__.f[key](chunkId, promises);
+/******/ 				return promises;
+/******/ 			}, []));
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/get javascript chunk filename */
+/******/ 	(() => {
+/******/ 		// This function allow to reference async chunks and sibling chunks for the entrypoint
+/******/ 		__webpack_require__.u = (chunkId) => {
+/******/ 			// return url for filenames based on template
+/******/ 			return "" + chunkId + ".js";
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* 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/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_ml_src_MCL_mcl-worker_js-node_modules_datagrok-librar-e4203d": 1
+/******/ 		};
+/******/ 		
+/******/ 		// importScripts chunk loading
+/******/ 		var installChunk = (data) => {
+/******/ 			var [chunkIds, moreModules, runtime] = data;
+/******/ 			for(var moduleId in moreModules) {
+/******/ 				if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ 					__webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/ 				}
+/******/ 			}
+/******/ 			if(runtime) runtime(__webpack_require__);
+/******/ 			while(chunkIds.length)
+/******/ 				installedChunks[chunkIds.pop()] = 1;
+/******/ 			parentChunkLoadingFunction(data);
+/******/ 		};
+/******/ 		__webpack_require__.f.i = (chunkId, promises) => {
+/******/ 			// "1" is the signal for "already loaded"
+/******/ 			if(!installedChunks[chunkId]) {
+/******/ 				if(true) { // all chunks have JS
+/******/ 					importScripts(__webpack_require__.p + __webpack_require__.u(chunkId));
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 		
+/******/ 		var chunkLoadingGlobal = self["webpackChunkeda"] = self["webpackChunkeda"] || [];
+/******/ 		var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);
+/******/ 		chunkLoadingGlobal.push = installChunk;
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/startup chunk dependencies */
+/******/ 	(() => {
+/******/ 		var next = __webpack_require__.x;
+/******/ 		__webpack_require__.x = () => {
+/******/ 			return __webpack_require__.e("vendors-node_modules_datagrok-libraries_math_src_webGPU_sparse-matrix_webGPU-sparse-matrix_js-07693f").then(next);
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// run startup
+/******/ 	var __webpack_exports__ = __webpack_require__.x();
+/******/ 	eda = __webpack_exports__;
+/******/ 	
+/******/ })()
+;
+//# sourceMappingURL=vendors-node_modules_datagrok-libraries_ml_src_MCL_mcl-worker_js-node_modules_datagrok-librar-e4203d.js.map