@datagrok/eda 1.3.4 → 1.4.0

package/dist/415.js.map

@@ -1 +1 @@
-{"version":3,"file":"415.js","mappings":"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","sources":["webpack://eda/./node_modules/umap-js/dist/heap.js","webpack://eda/./node_modules/umap-js/dist/index.js","webpack://eda/./node_modules/umap-js/dist/matrix.js","webpack://eda/./node_modules/umap-js/dist/nn_descent.js","webpack://eda/./node_modules/umap-js/dist/tree.js","webpack://eda/./node_modules/umap-js/dist/umap.js","webpack://eda/./node_modules/umap-js/dist/utils.js","webpack://eda/./node_modules/umap-js/node_modules/is-any-array/src/index.js","webpack://eda/./node_modules/umap-js/node_modules/ml-levenberg-marquardt/src/errorCalculation.js","webpack://eda/./node_modules/umap-js/node_modules/ml-levenberg-marquardt/src/step.js","webpack://eda/./node_modules/umap-js/node_modules/ml-levenberg-marquardt/src/index.js"],"sourcesContent":["\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.smallestFlagged = exports.deheapSort = exports.buildCandidates = exports.uncheckedHeapPush = exports.heapPush = exports.rejectionSample = exports.makeHeap = void 0;\nvar utils = __importStar(require(\"./utils\"));\nfunction makeHeap(nPoints, size) {\n    var makeArrays = function (fillValue) {\n        return utils.empty(nPoints).map(function () {\n            return utils.filled(size, fillValue);\n        });\n    };\n    var heap = [];\n    heap.push(makeArrays(-1));\n    heap.push(makeArrays(Infinity));\n    heap.push(makeArrays(0));\n    return heap;\n}\nexports.makeHeap = makeHeap;\nfunction rejectionSample(nSamples, poolSize, random) {\n    var result = utils.zeros(nSamples);\n    for (var i = 0; i < nSamples; i++) {\n        var rejectSample = true;\n        var j = 0;\n        while (rejectSample) {\n            j = utils.tauRandInt(poolSize, random);\n            var broken = false;\n            for (var k = 0; k < i; k++) {\n                if (j === result[k]) {\n                    broken = true;\n                    break;\n                }\n            }\n            if (!broken)\n                rejectSample = false;\n        }\n        result[i] = j;\n    }\n    return result;\n}\nexports.rejectionSample = rejectionSample;\nfunction heapPush(heap, row, weight, index, flag) {\n    row = Math.floor(row);\n    var indices = heap[0][row];\n    var weights = heap[1][row];\n    var isNew = heap[2][row];\n    if (weight >= weights[0]) {\n        return 0;\n    }\n    for (var i = 0; i < indices.length; i++) {\n        if (index === indices[i]) {\n            return 0;\n        }\n    }\n    return uncheckedHeapPush(heap, row, weight, index, flag);\n}\nexports.heapPush = heapPush;\nfunction uncheckedHeapPush(heap, row, weight, index, flag) {\n    var indices = heap[0][row];\n    var weights = heap[1][row];\n    var isNew = heap[2][row];\n    if (weight >= weights[0]) {\n        return 0;\n    }\n    weights[0] = weight;\n    indices[0] = index;\n    isNew[0] = flag;\n    var i = 0;\n    var iSwap = 0;\n    while (true) {\n        var ic1 = 2 * i + 1;\n        var ic2 = ic1 + 1;\n        var heapShape2 = heap[0][0].length;\n        if (ic1 >= heapShape2) {\n            break;\n        }\n        else if (ic2 >= heapShape2) {\n            if (weights[ic1] > weight) {\n                iSwap = ic1;\n            }\n            else {\n                break;\n            }\n        }\n        else if (weights[ic1] >= weights[ic2]) {\n            if (weight < weights[ic1]) {\n                iSwap = ic1;\n            }\n            else {\n                break;\n            }\n        }\n        else {\n            if (weight < weights[ic2]) {\n                iSwap = ic2;\n            }\n            else {\n                break;\n            }\n        }\n        weights[i] = weights[iSwap];\n        indices[i] = indices[iSwap];\n        isNew[i] = isNew[iSwap];\n        i = iSwap;\n    }\n    weights[i] = weight;\n    indices[i] = index;\n    isNew[i] = flag;\n    return 1;\n}\nexports.uncheckedHeapPush = uncheckedHeapPush;\nfunction buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random) {\n    var candidateNeighbors = makeHeap(nVertices, maxCandidates);\n    for (var i = 0; i < nVertices; i++) {\n        for (var j = 0; j < nNeighbors; j++) {\n            if (currentGraph[0][i][j] < 0) {\n                continue;\n            }\n            var idx = currentGraph[0][i][j];\n            var isn = currentGraph[2][i][j];\n            var d = utils.tauRand(random);\n            heapPush(candidateNeighbors, i, d, idx, isn);\n            heapPush(candidateNeighbors, idx, d, i, isn);\n            currentGraph[2][i][j] = 0;\n        }\n    }\n    return candidateNeighbors;\n}\nexports.buildCandidates = buildCandidates;\nfunction deheapSort(heap) {\n    var indices = heap[0];\n    var weights = heap[1];\n    for (var i = 0; i < indices.length; i++) {\n        var indHeap = indices[i];\n        var distHeap = weights[i];\n        for (var j = 0; j < indHeap.length - 1; j++) {\n            var indHeapIndex = indHeap.length - j - 1;\n            var distHeapIndex = distHeap.length - j - 1;\n            var temp1 = indHeap[0];\n            indHeap[0] = indHeap[indHeapIndex];\n            indHeap[indHeapIndex] = temp1;\n            var temp2 = distHeap[0];\n            distHeap[0] = distHeap[distHeapIndex];\n            distHeap[distHeapIndex] = temp2;\n            siftDown(distHeap, indHeap, distHeapIndex, 0);\n        }\n    }\n    return { indices: indices, weights: weights };\n}\nexports.deheapSort = deheapSort;\nfunction siftDown(heap1, heap2, ceiling, elt) {\n    while (elt * 2 + 1 < ceiling) {\n        var leftChild = elt * 2 + 1;\n        var rightChild = leftChild + 1;\n        var swap = elt;\n        if (heap1[swap] < heap1[leftChild]) {\n            swap = leftChild;\n        }\n        if (rightChild < ceiling && heap1[swap] < heap1[rightChild]) {\n            swap = rightChild;\n        }\n        if (swap === elt) {\n            break;\n        }\n        else {\n            var temp1 = heap1[elt];\n            heap1[elt] = heap1[swap];\n            heap1[swap] = temp1;\n            var temp2 = heap2[elt];\n            heap2[elt] = heap2[swap];\n            heap2[swap] = temp2;\n            elt = swap;\n        }\n    }\n}\nfunction smallestFlagged(heap, row) {\n    var ind = heap[0][row];\n    var dist = heap[1][row];\n    var flag = heap[2][row];\n    var minDist = Infinity;\n    var resultIndex = -1;\n    for (var i = 0; i > ind.length; i++) {\n        if (flag[i] === 1 && dist[i] < minDist) {\n            minDist = dist[i];\n            resultIndex = i;\n        }\n    }\n    if (resultIndex >= 0) {\n        flag[resultIndex] = 0;\n        return Math.floor(ind[resultIndex]);\n    }\n    else {\n        return -1;\n    }\n}\nexports.smallestFlagged = smallestFlagged;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar umap_1 = require(\"./umap\");\nObject.defineProperty(exports, \"UMAP\", { enumerable: true, get: function () { return umap_1.UMAP; } });\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar _a;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getCSR = exports.normalize = exports.eliminateZeros = exports.multiplyScalar = exports.maximum = exports.subtract = exports.add = exports.pairwiseMultiply = exports.identity = exports.transpose = exports.SparseMatrix = void 0;\nvar utils = __importStar(require(\"./utils\"));\nvar SparseMatrix = (function () {\n    function SparseMatrix(rows, cols, values, dims) {\n        this.entries = new Map();\n        this.nRows = 0;\n        this.nCols = 0;\n        if (rows.length !== cols.length || rows.length !== values.length) {\n            throw new Error('rows, cols and values arrays must all have the same length');\n        }\n        this.nRows = dims[0];\n        this.nCols = dims[1];\n        for (var i = 0; i < values.length; i++) {\n            var row = rows[i];\n            var col = cols[i];\n            this.checkDims(row, col);\n            var key = this.makeKey(row, col);\n            this.entries.set(key, { value: values[i], row: row, col: col });\n        }\n    }\n    SparseMatrix.prototype.makeKey = function (row, col) {\n        return row + \":\" + col;\n    };\n    SparseMatrix.prototype.checkDims = function (row, col) {\n        var withinBounds = row < this.nRows && col < this.nCols;\n        if (!withinBounds) {\n            throw new Error('row and/or col specified outside of matrix dimensions');\n        }\n    };\n    SparseMatrix.prototype.set = function (row, col, value) {\n        this.checkDims(row, col);\n        var key = this.makeKey(row, col);\n        if (!this.entries.has(key)) {\n            this.entries.set(key, { value: value, row: row, col: col });\n        }\n        else {\n            this.entries.get(key).value = value;\n        }\n    };\n    SparseMatrix.prototype.get = function (row, col, defaultValue) {\n        if (defaultValue === void 0) { defaultValue = 0; }\n        this.checkDims(row, col);\n        var key = this.makeKey(row, col);\n        if (this.entries.has(key)) {\n            return this.entries.get(key).value;\n        }\n        else {\n            return defaultValue;\n        }\n    };\n    SparseMatrix.prototype.getAll = function (ordered) {\n        if (ordered === void 0) { ordered = true; }\n        var rowColValues = [];\n        this.entries.forEach(function (value) {\n            rowColValues.push(value);\n        });\n        if (ordered) {\n            rowColValues.sort(function (a, b) {\n                if (a.row === b.row) {\n                    return a.col - b.col;\n                }\n                else {\n                    return a.row - b.row;\n                }\n            });\n        }\n        return rowColValues;\n    };\n    SparseMatrix.prototype.getDims = function () {\n        return [this.nRows, this.nCols];\n    };\n    SparseMatrix.prototype.getRows = function () {\n        return Array.from(this.entries, function (_a) {\n            var _b = __read(_a, 2), key = _b[0], value = _b[1];\n            return value.row;\n        });\n    };\n    SparseMatrix.prototype.getCols = function () {\n        return Array.from(this.entries, function (_a) {\n            var _b = __read(_a, 2), key = _b[0], value = _b[1];\n            return value.col;\n        });\n    };\n    SparseMatrix.prototype.getValues = function () {\n        return Array.from(this.entries, function (_a) {\n            var _b = __read(_a, 2), key = _b[0], value = _b[1];\n            return value.value;\n        });\n    };\n    SparseMatrix.prototype.forEach = function (fn) {\n        this.entries.forEach(function (value) { return fn(value.value, value.row, value.col); });\n    };\n    SparseMatrix.prototype.map = function (fn) {\n        var vals = [];\n        this.entries.forEach(function (value) {\n            vals.push(fn(value.value, value.row, value.col));\n        });\n        var dims = [this.nRows, this.nCols];\n        return new SparseMatrix(this.getRows(), this.getCols(), vals, dims);\n    };\n    SparseMatrix.prototype.toArray = function () {\n        var _this = this;\n        var rows = utils.empty(this.nRows);\n        var output = rows.map(function () {\n            return utils.zeros(_this.nCols);\n        });\n        this.entries.forEach(function (value) {\n            output[value.row][value.col] = value.value;\n        });\n        return output;\n    };\n    return SparseMatrix;\n}());\nexports.SparseMatrix = SparseMatrix;\nfunction transpose(matrix) {\n    var cols = [];\n    var rows = [];\n    var vals = [];\n    matrix.forEach(function (value, row, col) {\n        cols.push(row);\n        rows.push(col);\n        vals.push(value);\n    });\n    var dims = [matrix.nCols, matrix.nRows];\n    return new SparseMatrix(rows, cols, vals, dims);\n}\nexports.transpose = transpose;\nfunction identity(size) {\n    var _a = __read(size, 1), rows = _a[0];\n    var matrix = new SparseMatrix([], [], [], size);\n    for (var i = 0; i < rows; i++) {\n        matrix.set(i, i, 1);\n    }\n    return matrix;\n}\nexports.identity = identity;\nfunction pairwiseMultiply(a, b) {\n    return elementWise(a, b, function (x, y) { return x * y; });\n}\nexports.pairwiseMultiply = pairwiseMultiply;\nfunction add(a, b) {\n    return elementWise(a, b, function (x, y) { return x + y; });\n}\nexports.add = add;\nfunction subtract(a, b) {\n    return elementWise(a, b, function (x, y) { return x - y; });\n}\nexports.subtract = subtract;\nfunction maximum(a, b) {\n    return elementWise(a, b, function (x, y) { return (x > y ? x : y); });\n}\nexports.maximum = maximum;\nfunction multiplyScalar(a, scalar) {\n    return a.map(function (value) {\n        return value * scalar;\n    });\n}\nexports.multiplyScalar = multiplyScalar;\nfunction eliminateZeros(m) {\n    var zeroIndices = new Set();\n    var values = m.getValues();\n    var rows = m.getRows();\n    var cols = m.getCols();\n    for (var i = 0; i < values.length; i++) {\n        if (values[i] === 0) {\n            zeroIndices.add(i);\n        }\n    }\n    var removeByZeroIndex = function (_, index) { return !zeroIndices.has(index); };\n    var nextValues = values.filter(removeByZeroIndex);\n    var nextRows = rows.filter(removeByZeroIndex);\n    var nextCols = cols.filter(removeByZeroIndex);\n    return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());\n}\nexports.eliminateZeros = eliminateZeros;\nfunction normalize(m, normType) {\n    var e_1, _a;\n    if (normType === void 0) { normType = \"l2\"; }\n    var normFn = normFns[normType];\n    var colsByRow = new Map();\n    m.forEach(function (_, row, col) {\n        var cols = colsByRow.get(row) || [];\n        cols.push(col);\n        colsByRow.set(row, cols);\n    });\n    var nextMatrix = new SparseMatrix([], [], [], m.getDims());\n    var _loop_1 = function (row) {\n        var cols = colsByRow.get(row).sort();\n        var vals = cols.map(function (col) { return m.get(row, col); });\n        var norm = normFn(vals);\n        for (var i = 0; i < norm.length; i++) {\n            nextMatrix.set(row, cols[i], norm[i]);\n        }\n    };\n    try {\n        for (var _b = __values(colsByRow.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var row = _c.value;\n            _loop_1(row);\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n    return nextMatrix;\n}\nexports.normalize = normalize;\nvar normFns = (_a = {},\n    _a[\"max\"] = function (xs) {\n        var max = -Infinity;\n        for (var i = 0; i < xs.length; i++) {\n            max = xs[i] > max ? xs[i] : max;\n        }\n        return xs.map(function (x) { return x / max; });\n    },\n    _a[\"l1\"] = function (xs) {\n        var sum = 0;\n        for (var i = 0; i < xs.length; i++) {\n            sum += xs[i];\n        }\n        return xs.map(function (x) { return x / sum; });\n    },\n    _a[\"l2\"] = function (xs) {\n        var sum = 0;\n        for (var i = 0; i < xs.length; i++) {\n            sum += Math.pow(xs[i], 2);\n        }\n        return xs.map(function (x) { return Math.sqrt(Math.pow(x, 2) / sum); });\n    },\n    _a);\nfunction elementWise(a, b, op) {\n    var visited = new Set();\n    var rows = [];\n    var cols = [];\n    var vals = [];\n    var operate = function (row, col) {\n        rows.push(row);\n        cols.push(col);\n        var nextValue = op(a.get(row, col), b.get(row, col));\n        vals.push(nextValue);\n    };\n    var valuesA = a.getValues();\n    var rowsA = a.getRows();\n    var colsA = a.getCols();\n    for (var i = 0; i < valuesA.length; i++) {\n        var row = rowsA[i];\n        var col = colsA[i];\n        var key = row + \":\" + col;\n        visited.add(key);\n        operate(row, col);\n    }\n    var valuesB = b.getValues();\n    var rowsB = b.getRows();\n    var colsB = b.getCols();\n    for (var i = 0; i < valuesB.length; i++) {\n        var row = rowsB[i];\n        var col = colsB[i];\n        var key = row + \":\" + col;\n        if (visited.has(key))\n            continue;\n        operate(row, col);\n    }\n    var dims = [a.nRows, a.nCols];\n    return new SparseMatrix(rows, cols, vals, dims);\n}\nfunction getCSR(x) {\n    var entries = [];\n    x.forEach(function (value, row, col) {\n        entries.push({ value: value, row: row, col: col });\n    });\n    entries.sort(function (a, b) {\n        if (a.row === b.row) {\n            return a.col - b.col;\n        }\n        else {\n            return a.row - b.row;\n        }\n    });\n    var indices = [];\n    var values = [];\n    var indptr = [];\n    var currentRow = -1;\n    for (var i = 0; i < entries.length; i++) {\n        var _a = entries[i], row = _a.row, col = _a.col, value = _a.value;\n        if (row !== currentRow) {\n            currentRow = row;\n            indptr.push(i);\n        }\n        indices.push(col);\n        values.push(value);\n    }\n    return { indices: indices, values: values, indptr: indptr };\n}\nexports.getCSR = getCSR;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.initializeSearch = exports.makeInitializedNNSearch = exports.makeInitializations = exports.makeNNDescent = void 0;\nvar heap = __importStar(require(\"./heap\"));\nvar matrix = __importStar(require(\"./matrix\"));\nvar tree = __importStar(require(\"./tree\"));\nvar utils = __importStar(require(\"./utils\"));\nfunction makeNNDescent(distanceFn, random) {\n    return function nNDescent(data, leafArray, nNeighbors, nIters, maxCandidates, delta, rho, rpTreeInit) {\n        if (nIters === void 0) { nIters = 10; }\n        if (maxCandidates === void 0) { maxCandidates = 50; }\n        if (delta === void 0) { delta = 0.001; }\n        if (rho === void 0) { rho = 0.5; }\n        if (rpTreeInit === void 0) { rpTreeInit = true; }\n        var nVertices = data.length;\n        var currentGraph = heap.makeHeap(data.length, nNeighbors);\n        for (var i = 0; i < data.length; i++) {\n            var indices = heap.rejectionSample(nNeighbors, data.length, random);\n            for (var j = 0; j < indices.length; j++) {\n                var d = distanceFn(data[i], data[indices[j]]);\n                heap.heapPush(currentGraph, i, d, indices[j], 1);\n                heap.heapPush(currentGraph, indices[j], d, i, 1);\n            }\n        }\n        if (rpTreeInit) {\n            for (var n = 0; n < leafArray.length; n++) {\n                for (var i = 0; i < leafArray[n].length; i++) {\n                    if (leafArray[n][i] < 0) {\n                        break;\n                    }\n                    for (var j = i + 1; j < leafArray[n].length; j++) {\n                        if (leafArray[n][j] < 0) {\n                            break;\n                        }\n                        var d = distanceFn(data[leafArray[n][i]], data[leafArray[n][j]]);\n                        heap.heapPush(currentGraph, leafArray[n][i], d, leafArray[n][j], 1);\n                        heap.heapPush(currentGraph, leafArray[n][j], d, leafArray[n][i], 1);\n                    }\n                }\n            }\n        }\n        for (var n = 0; n < nIters; n++) {\n            var candidateNeighbors = heap.buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random);\n            var c = 0;\n            for (var i = 0; i < nVertices; i++) {\n                for (var j = 0; j < maxCandidates; j++) {\n                    var p = Math.floor(candidateNeighbors[0][i][j]);\n                    if (p < 0 || utils.tauRand(random) < rho) {\n                        continue;\n                    }\n                    for (var k = 0; k < maxCandidates; k++) {\n                        var q = Math.floor(candidateNeighbors[0][i][k]);\n                        var cj = candidateNeighbors[2][i][j];\n                        var ck = candidateNeighbors[2][i][k];\n                        if (q < 0 || (!cj && !ck)) {\n                            continue;\n                        }\n                        var d = distanceFn(data[p], data[q]);\n                        c += heap.heapPush(currentGraph, p, d, q, 1);\n                        c += heap.heapPush(currentGraph, q, d, p, 1);\n                    }\n                }\n            }\n            if (c <= delta * nNeighbors * data.length) {\n                break;\n            }\n        }\n        var sorted = heap.deheapSort(currentGraph);\n        return sorted;\n    };\n}\nexports.makeNNDescent = makeNNDescent;\nfunction makeInitializations(distanceFn) {\n    function initFromRandom(nNeighbors, data, queryPoints, _heap, random) {\n        for (var i = 0; i < queryPoints.length; i++) {\n            var indices = utils.rejectionSample(nNeighbors, data.length, random);\n            for (var j = 0; j < indices.length; j++) {\n                if (indices[j] < 0) {\n                    continue;\n                }\n                var d = distanceFn(data[indices[j]], queryPoints[i]);\n                heap.heapPush(_heap, i, d, indices[j], 1);\n            }\n        }\n    }\n    function initFromTree(_tree, data, queryPoints, _heap, random) {\n        for (var i = 0; i < queryPoints.length; i++) {\n            var indices = tree.searchFlatTree(queryPoints[i], _tree, random);\n            for (var j = 0; j < indices.length; j++) {\n                if (indices[j] < 0) {\n                    return;\n                }\n                var d = distanceFn(data[indices[j]], queryPoints[i]);\n                heap.heapPush(_heap, i, d, indices[j], 1);\n            }\n        }\n        return;\n    }\n    return { initFromRandom: initFromRandom, initFromTree: initFromTree };\n}\nexports.makeInitializations = makeInitializations;\nfunction makeInitializedNNSearch(distanceFn) {\n    return function nnSearchFn(data, graph, initialization, queryPoints) {\n        var e_1, _a;\n        var _b = matrix.getCSR(graph), indices = _b.indices, indptr = _b.indptr;\n        for (var i = 0; i < queryPoints.length; i++) {\n            var tried = new Set(initialization[0][i]);\n            while (true) {\n                var vertex = heap.smallestFlagged(initialization, i);\n                if (vertex === -1) {\n                    break;\n                }\n                var candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);\n                try {\n                    for (var candidates_1 = (e_1 = void 0, __values(candidates)), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {\n                        var candidate = candidates_1_1.value;\n                        if (candidate === vertex ||\n                            candidate === -1 ||\n                            tried.has(candidate)) {\n                            continue;\n                        }\n                        var d = distanceFn(data[candidate], queryPoints[i]);\n                        heap.uncheckedHeapPush(initialization, i, d, candidate, 1);\n                        tried.add(candidate);\n                    }\n                }\n                catch (e_1_1) { e_1 = { error: e_1_1 }; }\n                finally {\n                    try {\n                        if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);\n                    }\n                    finally { if (e_1) throw e_1.error; }\n                }\n            }\n        }\n        return initialization;\n    };\n}\nexports.makeInitializedNNSearch = makeInitializedNNSearch;\nfunction initializeSearch(forest, data, queryPoints, nNeighbors, initFromRandom, initFromTree, random) {\n    var e_2, _a;\n    var results = heap.makeHeap(queryPoints.length, nNeighbors);\n    initFromRandom(nNeighbors, data, queryPoints, results, random);\n    if (forest) {\n        try {\n            for (var forest_1 = __values(forest), forest_1_1 = forest_1.next(); !forest_1_1.done; forest_1_1 = forest_1.next()) {\n                var tree_1 = forest_1_1.value;\n                initFromTree(tree_1, data, queryPoints, results, random);\n            }\n        }\n        catch (e_2_1) { e_2 = { error: e_2_1 }; }\n        finally {\n            try {\n                if (forest_1_1 && !forest_1_1.done && (_a = forest_1.return)) _a.call(forest_1);\n            }\n            finally { if (e_2) throw e_2.error; }\n        }\n    }\n    return results;\n}\nexports.initializeSearch = initializeSearch;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spread = (this && this.__spread) || function () {\n    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n    return ar;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.searchFlatTree = exports.makeLeafArray = exports.makeForest = exports.FlatTree = void 0;\nvar utils = __importStar(require(\"./utils\"));\nvar FlatTree = (function () {\n    function FlatTree(hyperplanes, offsets, children, indices) {\n        this.hyperplanes = hyperplanes;\n        this.offsets = offsets;\n        this.children = children;\n        this.indices = indices;\n    }\n    return FlatTree;\n}());\nexports.FlatTree = FlatTree;\nfunction makeForest(data, nNeighbors, nTrees, random) {\n    var leafSize = Math.max(10, nNeighbors);\n    var trees = utils\n        .range(nTrees)\n        .map(function (_, i) { return makeTree(data, leafSize, i, random); });\n    var forest = trees.map(function (tree) { return flattenTree(tree, leafSize); });\n    return forest;\n}\nexports.makeForest = makeForest;\nfunction makeTree(data, leafSize, n, random) {\n    if (leafSize === void 0) { leafSize = 30; }\n    var indices = utils.range(data.length);\n    var tree = makeEuclideanTree(data, indices, leafSize, n, random);\n    return tree;\n}\nfunction makeEuclideanTree(data, indices, leafSize, q, random) {\n    if (leafSize === void 0) { leafSize = 30; }\n    if (indices.length > leafSize) {\n        var splitResults = euclideanRandomProjectionSplit(data, indices, random);\n        var indicesLeft = splitResults.indicesLeft, indicesRight = splitResults.indicesRight, hyperplane = splitResults.hyperplane, offset = splitResults.offset;\n        var leftChild = makeEuclideanTree(data, indicesLeft, leafSize, q + 1, random);\n        var rightChild = makeEuclideanTree(data, indicesRight, leafSize, q + 1, random);\n        var node = { leftChild: leftChild, rightChild: rightChild, isLeaf: false, hyperplane: hyperplane, offset: offset };\n        return node;\n    }\n    else {\n        var node = { indices: indices, isLeaf: true };\n        return node;\n    }\n}\nfunction euclideanRandomProjectionSplit(data, indices, random) {\n    var dim = data[0].length;\n    var leftIndex = utils.tauRandInt(indices.length, random);\n    var rightIndex = utils.tauRandInt(indices.length, random);\n    rightIndex += leftIndex === rightIndex ? 1 : 0;\n    rightIndex = rightIndex % indices.length;\n    var left = indices[leftIndex];\n    var right = indices[rightIndex];\n    var hyperplaneOffset = 0;\n    var hyperplaneVector = utils.zeros(dim);\n    for (var i = 0; i < hyperplaneVector.length; i++) {\n        hyperplaneVector[i] = data[left][i] - data[right][i];\n        hyperplaneOffset -=\n            (hyperplaneVector[i] * (data[left][i] + data[right][i])) / 2.0;\n    }\n    var nLeft = 0;\n    var nRight = 0;\n    var side = utils.zeros(indices.length);\n    for (var i = 0; i < indices.length; i++) {\n        var margin = hyperplaneOffset;\n        for (var d = 0; d < dim; d++) {\n            margin += hyperplaneVector[d] * data[indices[i]][d];\n        }\n        if (margin === 0) {\n            side[i] = utils.tauRandInt(2, random);\n            if (side[i] === 0) {\n                nLeft += 1;\n            }\n            else {\n                nRight += 1;\n            }\n        }\n        else if (margin > 0) {\n            side[i] = 0;\n            nLeft += 1;\n        }\n        else {\n            side[i] = 1;\n            nRight += 1;\n        }\n    }\n    var indicesLeft = utils.zeros(nLeft);\n    var indicesRight = utils.zeros(nRight);\n    nLeft = 0;\n    nRight = 0;\n    for (var i = 0; i < side.length; i++) {\n        if (side[i] === 0) {\n            indicesLeft[nLeft] = indices[i];\n            nLeft += 1;\n        }\n        else {\n            indicesRight[nRight] = indices[i];\n            nRight += 1;\n        }\n    }\n    return {\n        indicesLeft: indicesLeft,\n        indicesRight: indicesRight,\n        hyperplane: hyperplaneVector,\n        offset: hyperplaneOffset,\n    };\n}\nfunction flattenTree(tree, leafSize) {\n    var nNodes = numNodes(tree);\n    var nLeaves = numLeaves(tree);\n    var hyperplanes = utils\n        .range(nNodes)\n        .map(function () { return utils.zeros(tree.hyperplane ? tree.hyperplane.length : 0); });\n    var offsets = utils.zeros(nNodes);\n    var children = utils.range(nNodes).map(function () { return [-1, -1]; });\n    var indices = utils\n        .range(nLeaves)\n        .map(function () { return utils.range(leafSize).map(function () { return -1; }); });\n    recursiveFlatten(tree, hyperplanes, offsets, children, indices, 0, 0);\n    return new FlatTree(hyperplanes, offsets, children, indices);\n}\nfunction recursiveFlatten(tree, hyperplanes, offsets, children, indices, nodeNum, leafNum) {\n    var _a;\n    if (tree.isLeaf) {\n        children[nodeNum][0] = -leafNum;\n        (_a = indices[leafNum]).splice.apply(_a, __spread([0, tree.indices.length], tree.indices));\n        leafNum += 1;\n        return { nodeNum: nodeNum, leafNum: leafNum };\n    }\n    else {\n        hyperplanes[nodeNum] = tree.hyperplane;\n        offsets[nodeNum] = tree.offset;\n        children[nodeNum][0] = nodeNum + 1;\n        var oldNodeNum = nodeNum;\n        var res = recursiveFlatten(tree.leftChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n        nodeNum = res.nodeNum;\n        leafNum = res.leafNum;\n        children[oldNodeNum][1] = nodeNum + 1;\n        res = recursiveFlatten(tree.rightChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n        return { nodeNum: res.nodeNum, leafNum: res.leafNum };\n    }\n}\nfunction numNodes(tree) {\n    if (tree.isLeaf) {\n        return 1;\n    }\n    else {\n        return 1 + numNodes(tree.leftChild) + numNodes(tree.rightChild);\n    }\n}\nfunction numLeaves(tree) {\n    if (tree.isLeaf) {\n        return 1;\n    }\n    else {\n        return numLeaves(tree.leftChild) + numLeaves(tree.rightChild);\n    }\n}\nfunction makeLeafArray(rpForest) {\n    var e_1, _a;\n    if (rpForest.length > 0) {\n        var output = [];\n        try {\n            for (var rpForest_1 = __values(rpForest), rpForest_1_1 = rpForest_1.next(); !rpForest_1_1.done; rpForest_1_1 = rpForest_1.next()) {\n                var tree = rpForest_1_1.value;\n                output.push.apply(output, __spread(tree.indices));\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (rpForest_1_1 && !rpForest_1_1.done && (_a = rpForest_1.return)) _a.call(rpForest_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return output;\n    }\n    else {\n        return [[-1]];\n    }\n}\nexports.makeLeafArray = makeLeafArray;\nfunction selectSide(hyperplane, offset, point, random) {\n    var margin = offset;\n    for (var d = 0; d < point.length; d++) {\n        margin += hyperplane[d] * point[d];\n    }\n    if (margin === 0) {\n        var side = utils.tauRandInt(2, random);\n        return side;\n    }\n    else if (margin > 0) {\n        return 0;\n    }\n    else {\n        return 1;\n    }\n}\nfunction searchFlatTree(point, tree, random) {\n    var node = 0;\n    while (tree.children[node][0] > 0) {\n        var side = selectSide(tree.hyperplanes[node], tree.offsets[node], point, random);\n        if (side === 0) {\n            node = tree.children[node][0];\n        }\n        else {\n            node = tree.children[node][1];\n        }\n    }\n    var index = -1 * tree.children[node][0];\n    return tree.indices[index];\n}\nexports.searchFlatTree = searchFlatTree;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spread = (this && this.__spread) || function () {\n    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n    return ar;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.initTransform = exports.resetLocalConnectivity = exports.fastIntersection = exports.findABParams = exports.cosine = exports.euclidean = exports.UMAP = void 0;\nvar heap = __importStar(require(\"./heap\"));\nvar matrix = __importStar(require(\"./matrix\"));\nvar nnDescent = __importStar(require(\"./nn_descent\"));\nvar tree = __importStar(require(\"./tree\"));\nvar utils = __importStar(require(\"./utils\"));\nvar ml_levenberg_marquardt_1 = __importDefault(require(\"ml-levenberg-marquardt\"));\nvar SMOOTH_K_TOLERANCE = 1e-5;\nvar MIN_K_DIST_SCALE = 1e-3;\nvar UMAP = (function () {\n    function UMAP(params) {\n        var _this = this;\n        if (params === void 0) { params = {}; }\n        this.learningRate = 1.0;\n        this.localConnectivity = 1.0;\n        this.minDist = 0.1;\n        this.nComponents = 2;\n        this.nEpochs = 0;\n        this.nNeighbors = 15;\n        this.negativeSampleRate = 5;\n        this.random = Math.random;\n        this.repulsionStrength = 1.0;\n        this.setOpMixRatio = 1.0;\n        this.spread = 1.0;\n        this.transformQueueSize = 4.0;\n        this.targetMetric = \"categorical\";\n        this.targetWeight = 0.5;\n        this.targetNNeighbors = this.nNeighbors;\n        this.distanceFn = euclidean;\n        this.isInitialized = false;\n        this.rpForest = [];\n        this.embedding = [];\n        this.optimizationState = new OptimizationState();\n        var setParam = function (key) {\n            if (params[key] !== undefined)\n                _this[key] = params[key];\n        };\n        setParam('distanceFn');\n        setParam('learningRate');\n        setParam('localConnectivity');\n        setParam('minDist');\n        setParam('nComponents');\n        setParam('nEpochs');\n        setParam('nNeighbors');\n        setParam('negativeSampleRate');\n        setParam('random');\n        setParam('repulsionStrength');\n        setParam('setOpMixRatio');\n        setParam('spread');\n        setParam('transformQueueSize');\n    }\n    UMAP.prototype.fit = function (X) {\n        this.initializeFit(X);\n        this.optimizeLayout();\n        return this.embedding;\n    };\n    UMAP.prototype.fitAsync = function (X, callback) {\n        if (callback === void 0) { callback = function () { return true; }; }\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        this.initializeFit(X);\n                        return [4, this.optimizeLayoutAsync(callback)];\n                    case 1:\n                        _a.sent();\n                        return [2, this.embedding];\n                }\n            });\n        });\n    };\n    UMAP.prototype.setSupervisedProjection = function (Y, params) {\n        if (params === void 0) { params = {}; }\n        this.Y = Y;\n        this.targetMetric = params.targetMetric || this.targetMetric;\n        this.targetWeight = params.targetWeight || this.targetWeight;\n        this.targetNNeighbors = params.targetNNeighbors || this.targetNNeighbors;\n    };\n    UMAP.prototype.setPrecomputedKNN = function (knnIndices, knnDistances) {\n        this.knnIndices = knnIndices;\n        this.knnDistances = knnDistances;\n    };\n    UMAP.prototype.initializeFit = function (X) {\n        if (X.length <= this.nNeighbors) {\n            throw new Error(\"Not enough data points (\" + X.length + \") to create nNeighbors: \" + this.nNeighbors + \".  Add more data points or adjust the configuration.\");\n        }\n        if (this.X === X && this.isInitialized) {\n            return this.getNEpochs();\n        }\n        this.X = X;\n        if (!this.knnIndices && !this.knnDistances) {\n            var knnResults = this.nearestNeighbors(X);\n            this.knnIndices = knnResults.knnIndices;\n            this.knnDistances = knnResults.knnDistances;\n        }\n        this.graph = this.fuzzySimplicialSet(X, this.nNeighbors, this.setOpMixRatio);\n        this.makeSearchFns();\n        this.searchGraph = this.makeSearchGraph(X);\n        this.processGraphForSupervisedProjection();\n        var _a = this.initializeSimplicialSetEmbedding(), head = _a.head, tail = _a.tail, epochsPerSample = _a.epochsPerSample;\n        this.optimizationState.head = head;\n        this.optimizationState.tail = tail;\n        this.optimizationState.epochsPerSample = epochsPerSample;\n        this.initializeOptimization();\n        this.prepareForOptimizationLoop();\n        this.isInitialized = true;\n        return this.getNEpochs();\n    };\n    UMAP.prototype.makeSearchFns = function () {\n        var _a = nnDescent.makeInitializations(this.distanceFn), initFromTree = _a.initFromTree, initFromRandom = _a.initFromRandom;\n        this.initFromTree = initFromTree;\n        this.initFromRandom = initFromRandom;\n        this.search = nnDescent.makeInitializedNNSearch(this.distanceFn);\n    };\n    UMAP.prototype.makeSearchGraph = function (X) {\n        var knnIndices = this.knnIndices;\n        var knnDistances = this.knnDistances;\n        var dims = [X.length, X.length];\n        var searchGraph = new matrix.SparseMatrix([], [], [], dims);\n        for (var i = 0; i < knnIndices.length; i++) {\n            var knn = knnIndices[i];\n            var distances = knnDistances[i];\n            for (var j = 0; j < knn.length; j++) {\n                var neighbor = knn[j];\n                var distance = distances[j];\n                if (distance > 0) {\n                    searchGraph.set(i, neighbor, distance);\n                }\n            }\n        }\n        var transpose = matrix.transpose(searchGraph);\n        return matrix.maximum(searchGraph, transpose);\n    };\n    UMAP.prototype.transform = function (toTransform) {\n        var _this = this;\n        var rawData = this.X;\n        if (rawData === undefined || rawData.length === 0) {\n            throw new Error('No data has been fit.');\n        }\n        var nNeighbors = Math.floor(this.nNeighbors * this.transformQueueSize);\n        nNeighbors = Math.min(rawData.length, nNeighbors);\n        var init = nnDescent.initializeSearch(this.rpForest, rawData, toTransform, nNeighbors, this.initFromRandom, this.initFromTree, this.random);\n        var result = this.search(rawData, this.searchGraph, init, toTransform);\n        var _a = heap.deheapSort(result), indices = _a.indices, distances = _a.weights;\n        indices = indices.map(function (x) { return x.slice(0, _this.nNeighbors); });\n        distances = distances.map(function (x) { return x.slice(0, _this.nNeighbors); });\n        var adjustedLocalConnectivity = Math.max(0, this.localConnectivity - 1);\n        var _b = this.smoothKNNDistance(distances, this.nNeighbors, adjustedLocalConnectivity), sigmas = _b.sigmas, rhos = _b.rhos;\n        var _c = this.computeMembershipStrengths(indices, distances, sigmas, rhos), rows = _c.rows, cols = _c.cols, vals = _c.vals;\n        var size = [toTransform.length, rawData.length];\n        var graph = new matrix.SparseMatrix(rows, cols, vals, size);\n        var normed = matrix.normalize(graph, \"l1\");\n        var csrMatrix = matrix.getCSR(normed);\n        var nPoints = toTransform.length;\n        var eIndices = utils.reshape2d(csrMatrix.indices, nPoints, this.nNeighbors);\n        var eWeights = utils.reshape2d(csrMatrix.values, nPoints, this.nNeighbors);\n        var embedding = initTransform(eIndices, eWeights, this.embedding);\n        var nEpochs = this.nEpochs\n            ? this.nEpochs / 3\n            : graph.nRows <= 10000\n                ? 100\n                : 30;\n        var graphMax = graph\n            .getValues()\n            .reduce(function (max, val) { return (val > max ? val : max); }, 0);\n        graph = graph.map(function (value) { return (value < graphMax / nEpochs ? 0 : value); });\n        graph = matrix.eliminateZeros(graph);\n        var epochsPerSample = this.makeEpochsPerSample(graph.getValues(), nEpochs);\n        var head = graph.getRows();\n        var tail = graph.getCols();\n        this.assignOptimizationStateParameters({\n            headEmbedding: embedding,\n            tailEmbedding: this.embedding,\n            head: head,\n            tail: tail,\n            currentEpoch: 0,\n            nEpochs: nEpochs,\n            nVertices: graph.getDims()[1],\n            epochsPerSample: epochsPerSample,\n        });\n        this.prepareForOptimizationLoop();\n        return this.optimizeLayout();\n    };\n    UMAP.prototype.processGraphForSupervisedProjection = function () {\n        var _a = this, Y = _a.Y, X = _a.X;\n        if (Y) {\n            if (Y.length !== X.length) {\n                throw new Error('Length of X and y must be equal');\n            }\n            if (this.targetMetric === \"categorical\") {\n                var lt = this.targetWeight < 1.0;\n                var farDist = lt ? 2.5 * (1.0 / (1.0 - this.targetWeight)) : 1.0e12;\n                this.graph = this.categoricalSimplicialSetIntersection(this.graph, Y, farDist);\n            }\n        }\n    };\n    UMAP.prototype.step = function () {\n        var currentEpoch = this.optimizationState.currentEpoch;\n        if (currentEpoch < this.getNEpochs()) {\n            this.optimizeLayoutStep(currentEpoch);\n        }\n        return this.optimizationState.currentEpoch;\n    };\n    UMAP.prototype.getEmbedding = function () {\n        return this.embedding;\n    };\n    UMAP.prototype.nearestNeighbors = function (X) {\n        var _a = this, distanceFn = _a.distanceFn, nNeighbors = _a.nNeighbors;\n        var log2 = function (n) { return Math.log(n) / Math.log(2); };\n        var metricNNDescent = nnDescent.makeNNDescent(distanceFn, this.random);\n        var round = function (n) {\n            return n === 0.5 ? 0 : Math.round(n);\n        };\n        var nTrees = 5 + Math.floor(round(Math.pow(X.length, 0.5) / 20.0));\n        var nIters = Math.max(5, Math.floor(Math.round(log2(X.length))));\n        this.rpForest = tree.makeForest(X, nNeighbors, nTrees, this.random);\n        var leafArray = tree.makeLeafArray(this.rpForest);\n        var _b = metricNNDescent(X, leafArray, nNeighbors, nIters), indices = _b.indices, weights = _b.weights;\n        return { knnIndices: indices, knnDistances: weights };\n    };\n    UMAP.prototype.fuzzySimplicialSet = function (X, nNeighbors, setOpMixRatio) {\n        if (setOpMixRatio === void 0) { setOpMixRatio = 1.0; }\n        var _a = this, _b = _a.knnIndices, knnIndices = _b === void 0 ? [] : _b, _c = _a.knnDistances, knnDistances = _c === void 0 ? [] : _c, localConnectivity = _a.localConnectivity;\n        var _d = this.smoothKNNDistance(knnDistances, nNeighbors, localConnectivity), sigmas = _d.sigmas, rhos = _d.rhos;\n        var _e = this.computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos), rows = _e.rows, cols = _e.cols, vals = _e.vals;\n        var size = [X.length, X.length];\n        var sparseMatrix = new matrix.SparseMatrix(rows, cols, vals, size);\n        var transpose = matrix.transpose(sparseMatrix);\n        var prodMatrix = matrix.pairwiseMultiply(sparseMatrix, transpose);\n        var a = matrix.subtract(matrix.add(sparseMatrix, transpose), prodMatrix);\n        var b = matrix.multiplyScalar(a, setOpMixRatio);\n        var c = matrix.multiplyScalar(prodMatrix, 1.0 - setOpMixRatio);\n        var result = matrix.add(b, c);\n        return result;\n    };\n    UMAP.prototype.categoricalSimplicialSetIntersection = function (simplicialSet, target, farDist, unknownDist) {\n        if (unknownDist === void 0) { unknownDist = 1.0; }\n        var intersection = fastIntersection(simplicialSet, target, unknownDist, farDist);\n        intersection = matrix.eliminateZeros(intersection);\n        return resetLocalConnectivity(intersection);\n    };\n    UMAP.prototype.smoothKNNDistance = function (distances, k, localConnectivity, nIter, bandwidth) {\n        if (localConnectivity === void 0) { localConnectivity = 1.0; }\n        if (nIter === void 0) { nIter = 64; }\n        if (bandwidth === void 0) { bandwidth = 1.0; }\n        var target = (Math.log(k) / Math.log(2)) * bandwidth;\n        var rho = utils.zeros(distances.length);\n        var result = utils.zeros(distances.length);\n        for (var i = 0; i < distances.length; i++) {\n            var lo = 0.0;\n            var hi = Infinity;\n            var mid = 1.0;\n            var ithDistances = distances[i];\n            var nonZeroDists = ithDistances.filter(function (d) { return d > 0.0; });\n            if (nonZeroDists.length >= localConnectivity) {\n                var index = Math.floor(localConnectivity);\n                var interpolation = localConnectivity - index;\n                if (index > 0) {\n                    rho[i] = nonZeroDists[index - 1];\n                    if (interpolation > SMOOTH_K_TOLERANCE) {\n                        rho[i] +=\n                            interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n                    }\n                }\n                else {\n                    rho[i] = interpolation * nonZeroDists[0];\n                }\n            }\n            else if (nonZeroDists.length > 0) {\n                rho[i] = utils.max(nonZeroDists);\n            }\n            for (var n = 0; n < nIter; n++) {\n                var psum = 0.0;\n                for (var j = 1; j < distances[i].length; j++) {\n                    var d = distances[i][j] - rho[i];\n                    if (d > 0) {\n                        psum += Math.exp(-(d / mid));\n                    }\n                    else {\n                        psum += 1.0;\n                    }\n                }\n                if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE) {\n                    break;\n                }\n                if (psum > target) {\n                    hi = mid;\n                    mid = (lo + hi) / 2.0;\n                }\n                else {\n                    lo = mid;\n                    if (hi === Infinity) {\n                        mid *= 2;\n                    }\n                    else {\n                        mid = (lo + hi) / 2.0;\n                    }\n                }\n            }\n            result[i] = mid;\n            if (rho[i] > 0.0) {\n                var meanIthDistances = utils.mean(ithDistances);\n                if (result[i] < MIN_K_DIST_SCALE * meanIthDistances) {\n                    result[i] = MIN_K_DIST_SCALE * meanIthDistances;\n                }\n            }\n            else {\n                var meanDistances = utils.mean(distances.map(utils.mean));\n                if (result[i] < MIN_K_DIST_SCALE * meanDistances) {\n                    result[i] = MIN_K_DIST_SCALE * meanDistances;\n                }\n            }\n        }\n        return { sigmas: result, rhos: rho };\n    };\n    UMAP.prototype.computeMembershipStrengths = function (knnIndices, knnDistances, sigmas, rhos) {\n        var nSamples = knnIndices.length;\n        var nNeighbors = knnIndices[0].length;\n        var rows = utils.zeros(nSamples * nNeighbors);\n        var cols = utils.zeros(nSamples * nNeighbors);\n        var vals = utils.zeros(nSamples * nNeighbors);\n        for (var i = 0; i < nSamples; i++) {\n            for (var j = 0; j < nNeighbors; j++) {\n                var val = 0;\n                if (knnIndices[i][j] === -1) {\n                    continue;\n                }\n                if (knnIndices[i][j] === i) {\n                    val = 0.0;\n                }\n                else if (knnDistances[i][j] - rhos[i] <= 0.0) {\n                    val = 1.0;\n                }\n                else {\n                    val = Math.exp(-((knnDistances[i][j] - rhos[i]) / sigmas[i]));\n                }\n                rows[i * nNeighbors + j] = i;\n                cols[i * nNeighbors + j] = knnIndices[i][j];\n                vals[i * nNeighbors + j] = val;\n            }\n        }\n        return { rows: rows, cols: cols, vals: vals };\n    };\n    UMAP.prototype.initializeSimplicialSetEmbedding = function () {\n        var _this = this;\n        var nEpochs = this.getNEpochs();\n        var nComponents = this.nComponents;\n        var graphValues = this.graph.getValues();\n        var graphMax = 0;\n        for (var i = 0; i < graphValues.length; i++) {\n            var value = graphValues[i];\n            if (graphMax < graphValues[i]) {\n                graphMax = value;\n            }\n        }\n        var graph = this.graph.map(function (value) {\n            if (value < graphMax / nEpochs) {\n                return 0;\n            }\n            else {\n                return value;\n            }\n        });\n        this.embedding = utils.zeros(graph.nRows).map(function () {\n            return utils.zeros(nComponents).map(function () {\n                return utils.tauRand(_this.random) * 20 + -10;\n            });\n        });\n        var weights = [];\n        var head = [];\n        var tail = [];\n        var rowColValues = graph.getAll();\n        for (var i = 0; i < rowColValues.length; i++) {\n            var entry = rowColValues[i];\n            if (entry.value) {\n                weights.push(entry.value);\n                tail.push(entry.row);\n                head.push(entry.col);\n            }\n        }\n        var epochsPerSample = this.makeEpochsPerSample(weights, nEpochs);\n        return { head: head, tail: tail, epochsPerSample: epochsPerSample };\n    };\n    UMAP.prototype.makeEpochsPerSample = function (weights, nEpochs) {\n        var result = utils.filled(weights.length, -1.0);\n        var max = utils.max(weights);\n        var nSamples = weights.map(function (w) { return (w / max) * nEpochs; });\n        nSamples.forEach(function (n, i) {\n            if (n > 0)\n                result[i] = nEpochs / nSamples[i];\n        });\n        return result;\n    };\n    UMAP.prototype.assignOptimizationStateParameters = function (state) {\n        Object.assign(this.optimizationState, state);\n    };\n    UMAP.prototype.prepareForOptimizationLoop = function () {\n        var _a = this, repulsionStrength = _a.repulsionStrength, learningRate = _a.learningRate, negativeSampleRate = _a.negativeSampleRate;\n        var _b = this.optimizationState, epochsPerSample = _b.epochsPerSample, headEmbedding = _b.headEmbedding, tailEmbedding = _b.tailEmbedding;\n        var dim = headEmbedding[0].length;\n        var moveOther = headEmbedding.length === tailEmbedding.length;\n        var epochsPerNegativeSample = epochsPerSample.map(function (e) { return e / negativeSampleRate; });\n        var epochOfNextNegativeSample = __spread(epochsPerNegativeSample);\n        var epochOfNextSample = __spread(epochsPerSample);\n        this.assignOptimizationStateParameters({\n            epochOfNextSample: epochOfNextSample,\n            epochOfNextNegativeSample: epochOfNextNegativeSample,\n            epochsPerNegativeSample: epochsPerNegativeSample,\n            moveOther: moveOther,\n            initialAlpha: learningRate,\n            alpha: learningRate,\n            gamma: repulsionStrength,\n            dim: dim,\n        });\n    };\n    UMAP.prototype.initializeOptimization = function () {\n        var headEmbedding = this.embedding;\n        var tailEmbedding = this.embedding;\n        var _a = this.optimizationState, head = _a.head, tail = _a.tail, epochsPerSample = _a.epochsPerSample;\n        var nEpochs = this.getNEpochs();\n        var nVertices = this.graph.nCols;\n        var _b = findABParams(this.spread, this.minDist), a = _b.a, b = _b.b;\n        this.assignOptimizationStateParameters({\n            headEmbedding: headEmbedding,\n            tailEmbedding: tailEmbedding,\n            head: head,\n            tail: tail,\n            epochsPerSample: epochsPerSample,\n            a: a,\n            b: b,\n            nEpochs: nEpochs,\n            nVertices: nVertices,\n        });\n    };\n    UMAP.prototype.optimizeLayoutStep = function (n) {\n        var optimizationState = this.optimizationState;\n        var head = optimizationState.head, tail = optimizationState.tail, headEmbedding = optimizationState.headEmbedding, tailEmbedding = optimizationState.tailEmbedding, epochsPerSample = optimizationState.epochsPerSample, epochOfNextSample = optimizationState.epochOfNextSample, epochOfNextNegativeSample = optimizationState.epochOfNextNegativeSample, epochsPerNegativeSample = optimizationState.epochsPerNegativeSample, moveOther = optimizationState.moveOther, initialAlpha = optimizationState.initialAlpha, alpha = optimizationState.alpha, gamma = optimizationState.gamma, a = optimizationState.a, b = optimizationState.b, dim = optimizationState.dim, nEpochs = optimizationState.nEpochs, nVertices = optimizationState.nVertices;\n        var clipValue = 4.0;\n        for (var i = 0; i < epochsPerSample.length; i++) {\n            if (epochOfNextSample[i] > n) {\n                continue;\n            }\n            var j = head[i];\n            var k = tail[i];\n            var current = headEmbedding[j];\n            var other = tailEmbedding[k];\n            var distSquared = rDist(current, other);\n            var gradCoeff = 0;\n            if (distSquared > 0) {\n                gradCoeff = -2.0 * a * b * Math.pow(distSquared, b - 1.0);\n                gradCoeff /= a * Math.pow(distSquared, b) + 1.0;\n            }\n            for (var d = 0; d < dim; d++) {\n                var gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n                current[d] += gradD * alpha;\n                if (moveOther) {\n                    other[d] += -gradD * alpha;\n                }\n            }\n            epochOfNextSample[i] += epochsPerSample[i];\n            var nNegSamples = Math.floor((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);\n            for (var p = 0; p < nNegSamples; p++) {\n                var k_1 = utils.tauRandInt(nVertices, this.random);\n                var other_1 = tailEmbedding[k_1];\n                var distSquared_1 = rDist(current, other_1);\n                var gradCoeff_1 = 0.0;\n                if (distSquared_1 > 0.0) {\n                    gradCoeff_1 = 2.0 * gamma * b;\n                    gradCoeff_1 /=\n                        (0.001 + distSquared_1) * (a * Math.pow(distSquared_1, b) + 1);\n                }\n                else if (j === k_1) {\n                    continue;\n                }\n                for (var d = 0; d < dim; d++) {\n                    var gradD = 4.0;\n                    if (gradCoeff_1 > 0.0) {\n                        gradD = clip(gradCoeff_1 * (current[d] - other_1[d]), clipValue);\n                    }\n                    current[d] += gradD * alpha;\n                }\n            }\n            epochOfNextNegativeSample[i] += nNegSamples * epochsPerNegativeSample[i];\n        }\n        optimizationState.alpha = initialAlpha * (1.0 - n / nEpochs);\n        optimizationState.currentEpoch += 1;\n        return headEmbedding;\n    };\n    UMAP.prototype.optimizeLayoutAsync = function (epochCallback) {\n        var _this = this;\n        if (epochCallback === void 0) { epochCallback = function () { return true; }; }\n        return new Promise(function (resolve, reject) {\n            var step = function () { return __awaiter(_this, void 0, void 0, function () {\n                var _a, nEpochs, currentEpoch, epochCompleted, shouldStop, isFinished;\n                return __generator(this, function (_b) {\n                    try {\n                        _a = this.optimizationState, nEpochs = _a.nEpochs, currentEpoch = _a.currentEpoch;\n                        this.embedding = this.optimizeLayoutStep(currentEpoch);\n                        epochCompleted = this.optimizationState.currentEpoch;\n                        shouldStop = epochCallback(epochCompleted) === false;\n                        isFinished = epochCompleted === nEpochs;\n                        if (!shouldStop && !isFinished) {\n                            setTimeout(function () { return step(); }, 0);\n                        }\n                        else {\n                            return [2, resolve(isFinished)];\n                        }\n                    }\n                    catch (err) {\n                        reject(err);\n                    }\n                    return [2];\n                });\n            }); };\n            setTimeout(function () { return step(); }, 0);\n        });\n    };\n    UMAP.prototype.optimizeLayout = function (epochCallback) {\n        if (epochCallback === void 0) { epochCallback = function () { return true; }; }\n        var isFinished = false;\n        var embedding = [];\n        while (!isFinished) {\n            var _a = this.optimizationState, nEpochs = _a.nEpochs, currentEpoch = _a.currentEpoch;\n            embedding = this.optimizeLayoutStep(currentEpoch);\n            var epochCompleted = this.optimizationState.currentEpoch;\n            var shouldStop = epochCallback(epochCompleted) === false;\n            isFinished = epochCompleted === nEpochs || shouldStop;\n        }\n        return embedding;\n    };\n    UMAP.prototype.getNEpochs = function () {\n        var graph = this.graph;\n        if (this.nEpochs > 0) {\n            return this.nEpochs;\n        }\n        var length = graph.nRows;\n        if (length <= 2500) {\n            return 500;\n        }\n        else if (length <= 5000) {\n            return 400;\n        }\n        else if (length <= 7500) {\n            return 300;\n        }\n        else {\n            return 200;\n        }\n    };\n    return UMAP;\n}());\nexports.UMAP = UMAP;\nfunction euclidean(x, y) {\n    var result = 0;\n    for (var i = 0; i < x.length; i++) {\n        result += Math.pow((x[i] - y[i]), 2);\n    }\n    return Math.sqrt(result);\n}\nexports.euclidean = euclidean;\nfunction cosine(x, y) {\n    var result = 0.0;\n    var normX = 0.0;\n    var normY = 0.0;\n    for (var i = 0; i < x.length; i++) {\n        result += x[i] * y[i];\n        normX += Math.pow(x[i], 2);\n        normY += Math.pow(y[i], 2);\n    }\n    if (normX === 0 && normY === 0) {\n        return 0;\n    }\n    else if (normX === 0 || normY === 0) {\n        return 1.0;\n    }\n    else {\n        return 1.0 - result / Math.sqrt(normX * normY);\n    }\n}\nexports.cosine = cosine;\nvar OptimizationState = (function () {\n    function OptimizationState() {\n        this.currentEpoch = 0;\n        this.headEmbedding = [];\n        this.tailEmbedding = [];\n        this.head = [];\n        this.tail = [];\n        this.epochsPerSample = [];\n        this.epochOfNextSample = [];\n        this.epochOfNextNegativeSample = [];\n        this.epochsPerNegativeSample = [];\n        this.moveOther = true;\n        this.initialAlpha = 1.0;\n        this.alpha = 1.0;\n        this.gamma = 1.0;\n        this.a = 1.5769434603113077;\n        this.b = 0.8950608779109733;\n        this.dim = 2;\n        this.nEpochs = 500;\n        this.nVertices = 0;\n    }\n    return OptimizationState;\n}());\nfunction clip(x, clipValue) {\n    if (x > clipValue)\n        return clipValue;\n    else if (x < -clipValue)\n        return -clipValue;\n    else\n        return x;\n}\nfunction rDist(x, y) {\n    var result = 0.0;\n    for (var i = 0; i < x.length; i++) {\n        result += Math.pow(x[i] - y[i], 2);\n    }\n    return result;\n}\nfunction findABParams(spread, minDist) {\n    var curve = function (_a) {\n        var _b = __read(_a, 2), a = _b[0], b = _b[1];\n        return function (x) {\n            return 1.0 / (1.0 + a * Math.pow(x, (2 * b)));\n        };\n    };\n    var xv = utils\n        .linear(0, spread * 3, 300)\n        .map(function (val) { return (val < minDist ? 1.0 : val); });\n    var yv = utils.zeros(xv.length).map(function (val, index) {\n        var gte = xv[index] >= minDist;\n        return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n    });\n    var initialValues = [0.5, 0.5];\n    var data = { x: xv, y: yv };\n    var options = {\n        damping: 1.5,\n        initialValues: initialValues,\n        gradientDifference: 10e-2,\n        maxIterations: 100,\n        errorTolerance: 10e-3,\n    };\n    var parameterValues = ml_levenberg_marquardt_1.default(data, curve, options).parameterValues;\n    var _a = __read(parameterValues, 2), a = _a[0], b = _a[1];\n    return { a: a, b: b };\n}\nexports.findABParams = findABParams;\nfunction fastIntersection(graph, target, unknownDist, farDist) {\n    if (unknownDist === void 0) { unknownDist = 1.0; }\n    if (farDist === void 0) { farDist = 5.0; }\n    return graph.map(function (value, row, col) {\n        if (target[row] === -1 || target[col] === -1) {\n            return value * Math.exp(-unknownDist);\n        }\n        else if (target[row] !== target[col]) {\n            return value * Math.exp(-farDist);\n        }\n        else {\n            return value;\n        }\n    });\n}\nexports.fastIntersection = fastIntersection;\nfunction resetLocalConnectivity(simplicialSet) {\n    simplicialSet = matrix.normalize(simplicialSet, \"max\");\n    var transpose = matrix.transpose(simplicialSet);\n    var prodMatrix = matrix.pairwiseMultiply(transpose, simplicialSet);\n    simplicialSet = matrix.add(simplicialSet, matrix.subtract(transpose, prodMatrix));\n    return matrix.eliminateZeros(simplicialSet);\n}\nexports.resetLocalConnectivity = resetLocalConnectivity;\nfunction initTransform(indices, weights, embedding) {\n    var result = utils\n        .zeros(indices.length)\n        .map(function (z) { return utils.zeros(embedding[0].length); });\n    for (var i = 0; i < indices.length; i++) {\n        for (var j = 0; j < indices[0].length; j++) {\n            for (var d = 0; d < embedding[0].length; d++) {\n                var a = indices[i][j];\n                result[i][d] += weights[i][j] * embedding[a][d];\n            }\n        }\n    }\n    return result;\n}\nexports.initTransform = initTransform;\n","\"use strict\";\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reshape2d = exports.rejectionSample = exports.max2d = exports.max = exports.mean = exports.sum = exports.linear = exports.ones = exports.zeros = exports.filled = exports.range = exports.empty = exports.norm = exports.tauRand = exports.tauRandInt = void 0;\nfunction tauRandInt(n, random) {\n    return Math.floor(random() * n);\n}\nexports.tauRandInt = tauRandInt;\nfunction tauRand(random) {\n    return random();\n}\nexports.tauRand = tauRand;\nfunction norm(vec) {\n    var e_1, _a;\n    var result = 0;\n    try {\n        for (var vec_1 = __values(vec), vec_1_1 = vec_1.next(); !vec_1_1.done; vec_1_1 = vec_1.next()) {\n            var item = vec_1_1.value;\n            result += Math.pow(item, 2);\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (vec_1_1 && !vec_1_1.done && (_a = vec_1.return)) _a.call(vec_1);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n    return Math.sqrt(result);\n}\nexports.norm = norm;\nfunction empty(n) {\n    var output = [];\n    for (var i = 0; i < n; i++) {\n        output.push(undefined);\n    }\n    return output;\n}\nexports.empty = empty;\nfunction range(n) {\n    return empty(n).map(function (_, i) { return i; });\n}\nexports.range = range;\nfunction filled(n, v) {\n    return empty(n).map(function () { return v; });\n}\nexports.filled = filled;\nfunction zeros(n) {\n    return filled(n, 0);\n}\nexports.zeros = zeros;\nfunction ones(n) {\n    return filled(n, 1);\n}\nexports.ones = ones;\nfunction linear(a, b, len) {\n    return empty(len).map(function (_, i) {\n        return a + i * ((b - a) / (len - 1));\n    });\n}\nexports.linear = linear;\nfunction sum(input) {\n    return input.reduce(function (sum, val) { return sum + val; });\n}\nexports.sum = sum;\nfunction mean(input) {\n    return sum(input) / input.length;\n}\nexports.mean = mean;\nfunction max(input) {\n    var max = 0;\n    for (var i = 0; i < input.length; i++) {\n        max = input[i] > max ? input[i] : max;\n    }\n    return max;\n}\nexports.max = max;\nfunction max2d(input) {\n    var max = 0;\n    for (var i = 0; i < input.length; i++) {\n        for (var j = 0; j < input[i].length; j++) {\n            max = input[i][j] > max ? input[i][j] : max;\n        }\n    }\n    return max;\n}\nexports.max2d = max2d;\nfunction rejectionSample(nSamples, poolSize, random) {\n    var result = zeros(nSamples);\n    for (var i = 0; i < nSamples; i++) {\n        var rejectSample = true;\n        while (rejectSample) {\n            var j = tauRandInt(poolSize, random);\n            var broken = false;\n            for (var k = 0; k < i; k++) {\n                if (j === result[k]) {\n                    broken = true;\n                    break;\n                }\n            }\n            if (!broken) {\n                rejectSample = false;\n            }\n            result[i] = j;\n        }\n    }\n    return result;\n}\nexports.rejectionSample = rejectionSample;\nfunction reshape2d(x, a, b) {\n    var rows = [];\n    var count = 0;\n    var index = 0;\n    if (x.length !== a * b) {\n        throw new Error('Array dimensions must match input length.');\n    }\n    for (var i = 0; i < a; i++) {\n        var col = [];\n        for (var j = 0; j < b; j++) {\n            col.push(x[index]);\n            index += 1;\n        }\n        rows.push(col);\n        count += 1;\n    }\n    return rows;\n}\nexports.reshape2d = reshape2d;\n","const toString = Object.prototype.toString;\n\nexport default function isAnyArray(object) {\n  return toString.call(object).endsWith('Array]');\n}\n","/**\n * Calculate current error\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} parameters - Array of current parameter values\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {number}\n */\nexport default function errorCalculation(\n  data,\n  parameters,\n  parameterizedFunction,\n) {\n  let error = 0;\n  const func = parameterizedFunction(parameters);\n\n  for (let i = 0; i < data.x.length; i++) {\n    error += Math.abs(data.y[i] - func(data.x[i]));\n  }\n\n  return error;\n}\n","import { inverse, Matrix } from 'ml-matrix';\n\n/**\n * Difference of the matrix function over the parameters\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} paramFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Matrix}\n */\nfunction gradientFunction(\n  data,\n  evaluatedData,\n  params,\n  gradientDifference,\n  paramFunction,\n) {\n  const n = params.length;\n  const m = data.x.length;\n\n  let ans = new Array(n);\n\n  for (let param = 0; param < n; param++) {\n    ans[param] = new Array(m);\n    let auxParams = params.slice();\n    auxParams[param] += gradientDifference;\n    let funcParam = paramFunction(auxParams);\n\n    for (let point = 0; point < m; point++) {\n      ans[param][point] = evaluatedData[point] - funcParam(data.x[point]);\n    }\n  }\n  return new Matrix(ans);\n}\n\n/**\n * Matrix function over the samples\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @return {Matrix}\n */\nfunction matrixFunction(data, evaluatedData) {\n  const m = data.x.length;\n\n  let ans = new Array(m);\n\n  for (let point = 0; point < m; point++) {\n    ans[point] = [data.y[point] - evaluatedData[point]];\n  }\n\n  return new Matrix(ans);\n}\n\n/**\n * Iteration for Levenberg-Marquardt\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} damping - Levenberg-Marquardt parameter\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Array<number>}\n */\nexport default function step(\n  data,\n  params,\n  damping,\n  gradientDifference,\n  parameterizedFunction,\n) {\n  let value = damping * gradientDifference * gradientDifference;\n  let identity = Matrix.eye(params.length, params.length, value);\n\n  const func = parameterizedFunction(params);\n\n  let evaluatedData = new Float64Array(data.x.length);\n  for (let i = 0; i < data.x.length; i++) {\n    evaluatedData[i] = func(data.x[i]);\n  }\n\n  let gradientFunc = gradientFunction(\n    data,\n    evaluatedData,\n    params,\n    gradientDifference,\n    parameterizedFunction,\n  );\n  let matrixFunc = matrixFunction(data, evaluatedData);\n  let inverseMatrix = inverse(\n    identity.add(gradientFunc.mmul(gradientFunc.transpose())),\n  );\n\n  params = new Matrix([params]);\n  params = params.sub(\n    inverseMatrix\n      .mmul(gradientFunc)\n      .mmul(matrixFunc)\n      .mul(gradientDifference)\n      .transpose(),\n  );\n\n  return params.to1DArray();\n}\n","import isArray from 'is-any-array';\n\nimport errorCalculation from './errorCalculation';\nimport step from './step';\n\n/**\n * Curve fitting algorithm\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @param {object} [options] - Options object\n * @param {number} [options.damping] - Levenberg-Marquardt parameter\n * @param {number} [options.gradientDifference = 10e-2] - Adjustment for decrease the damping parameter\n * @param {Array<number>} [options.minValues] - Minimum allowed values for parameters\n * @param {Array<number>} [options.maxValues] - Maximum allowed values for parameters\n * @param {Array<number>} [options.initialValues] - Array of initial parameter values\n * @param {number} [options.maxIterations = 100] - Maximum of allowed iterations\n * @param {number} [options.errorTolerance = 10e-3] - Minimum uncertainty allowed for each point\n * @return {{parameterValues: Array<number>, parameterError: number, iterations: number}}\n */\nexport default function levenbergMarquardt(\n  data,\n  parameterizedFunction,\n  options = {},\n) {\n  let {\n    maxIterations = 100,\n    gradientDifference = 10e-2,\n    damping = 0,\n    errorTolerance = 10e-3,\n    minValues,\n    maxValues,\n    initialValues,\n  } = options;\n\n  if (damping <= 0) {\n    throw new Error('The damping option must be a positive number');\n  } else if (!data.x || !data.y) {\n    throw new Error('The data parameter must have x and y elements');\n  } else if (\n    !isArray(data.x) ||\n    data.x.length < 2 ||\n    !isArray(data.y) ||\n    data.y.length < 2\n  ) {\n    throw new Error(\n      'The data parameter elements must be an array with more than 2 points',\n    );\n  } else if (data.x.length !== data.y.length) {\n    throw new Error('The data parameter elements must have the same size');\n  }\n\n  let parameters =\n    initialValues || new Array(parameterizedFunction.length).fill(1);\n  let parLen = parameters.length;\n  maxValues = maxValues || new Array(parLen).fill(Number.MAX_SAFE_INTEGER);\n  minValues = minValues || new Array(parLen).fill(Number.MIN_SAFE_INTEGER);\n\n  if (maxValues.length !== minValues.length) {\n    throw new Error('minValues and maxValues must be the same size');\n  }\n\n  if (!isArray(parameters)) {\n    throw new Error('initialValues must be an array');\n  }\n\n  let error = errorCalculation(data, parameters, parameterizedFunction);\n\n  let converged = error <= errorTolerance;\n\n  let iteration;\n  for (iteration = 0; iteration < maxIterations && !converged; iteration++) {\n    parameters = step(\n      data,\n      parameters,\n      damping,\n      gradientDifference,\n      parameterizedFunction,\n    );\n\n    for (let k = 0; k < parLen; k++) {\n      parameters[k] = Math.min(\n        Math.max(minValues[k], parameters[k]),\n        maxValues[k],\n      );\n    }\n\n    error = errorCalculation(data, parameters, parameterizedFunction);\n    if (isNaN(error)) break;\n    converged = error <= errorTolerance;\n  }\n\n  return {\n    parameterValues: parameters,\n    parameterError: error,\n    iterations: iteration,\n  };\n}\n"],"names":["__createBinding","this","Object","create","o","m","k","k2","undefined","defineProperty","enumerable","get","__setModuleDefault","v","value","__importStar","mod","__esModule","result","hasOwnProperty","call","exports","smallestFlagged","deheapSort","buildCandidates","uncheckedHeapPush","heapPush","rejectionSample","makeHeap","utils","nPoints","size","makeArrays","fillValue","empty","map","filled","heap","push","Infinity","row","weight","index","flag","Math","floor","indices","weights","i","length","isNew","iSwap","ic1","ic2","heapShape2","siftDown","heap1","heap2","ceiling","elt","leftChild","rightChild","swap","temp1","temp2","nSamples","poolSize","random","zeros","rejectSample","j","tauRandInt","broken","currentGraph","nVertices","nNeighbors","maxCandidates","candidateNeighbors","idx","isn","d","tauRand","indHeap","distHeap","indHeapIndex","distHeapIndex","ind","dist","minDist","resultIndex","umap_1","UMAP","_a","__read","n","Symbol","iterator","r","e","ar","next","done","error","__values","s","TypeError","getCSR","normalize","eliminateZeros","multiplyScalar","maximum","subtract","add","pairwiseMultiply","identity","transpose","SparseMatrix","rows","cols","values","dims","entries","Map","nRows","nCols","Error","col","checkDims","key","makeKey","set","prototype","has","defaultValue","getAll","ordered","rowColValues","forEach","sort","a","b","getDims","getRows","Array","from","_b","getCols","getValues","fn","vals","toArray","_this","output","matrix","elementWise","x","y","scalar","zeroIndices","Set","removeByZeroIndex","_","nextValues","filter","nextRows","nextCols","normType","e_1","normFn","normFns","colsByRow","nextMatrix","_loop_1","norm","keys","_c","e_1_1","return","xs","max","sum","pow","sqrt","op","visited","operate","nextValue","valuesA","rowsA","colsA","valuesB","rowsB","colsB","indptr","currentRow","initializeSearch","makeInitializedNNSearch","makeInitializations","makeNNDescent","tree","distanceFn","data","leafArray","nIters","delta","rho","rpTreeInit","c","p","q","cj","ck","initFromRandom","queryPoints","_heap","initFromTree","_tree","searchFlatTree","graph","initialization","tried","vertex","candidates","slice","candidates_1","candidates_1_1","candidate","forest","e_2","results","forest_1","forest_1_1","e_2_1","__spread","arguments","concat","makeLeafArray","makeForest","FlatTree","hyperplanes","offsets","children","makeEuclideanTree","leafSize","splitResults","dim","leftIndex","rightIndex","left","right","hyperplaneOffset","hyperplaneVector","nLeft","nRight","side","margin","indicesLeft","indicesRight","hyperplane","offset","euclideanRandomProjectionSplit","isLeaf","recursiveFlatten","nodeNum","leafNum","splice","apply","oldNodeNum","res","numNodes","numLeaves","selectSide","point","nTrees","range","makeTree","nNodes","nLeaves","flattenTree","rpForest","rpForest_1","rpForest_1_1","node","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","rejected","then","__generator","body","f","t","g","label","sent","trys","ops","verb","pop","__importDefault","initTransform","resetLocalConnectivity","fastIntersection","findABParams","cosine","euclidean","nnDescent","ml_levenberg_marquardt_1","SMOOTH_K_TOLERANCE","MIN_K_DIST_SCALE","params","learningRate","localConnectivity","nComponents","nEpochs","negativeSampleRate","repulsionStrength","setOpMixRatio","spread","transformQueueSize","targetMetric","targetWeight","targetNNeighbors","isInitialized","embedding","optimizationState","OptimizationState","setParam","fit","X","initializeFit","optimizeLayout","fitAsync","callback","optimizeLayoutAsync","setSupervisedProjection","Y","setPrecomputedKNN","knnIndices","knnDistances","getNEpochs","knnResults","nearestNeighbors","fuzzySimplicialSet","makeSearchFns","searchGraph","makeSearchGraph","processGraphForSupervisedProjection","initializeSimplicialSetEmbedding","head","tail","epochsPerSample","initializeOptimization","prepareForOptimizationLoop","search","knn","distances","neighbor","distance","transform","toTransform","rawData","min","init","adjustedLocalConnectivity","smoothKNNDistance","sigmas","rhos","computeMembershipStrengths","normed","csrMatrix","reshape2d","graphMax","reduce","val","makeEpochsPerSample","assignOptimizationStateParameters","headEmbedding","tailEmbedding","currentEpoch","farDist","categoricalSimplicialSetIntersection","optimizeLayoutStep","getEmbedding","metricNNDescent","round","log","log2","_d","_e","sparseMatrix","prodMatrix","simplicialSet","target","unknownDist","intersection","nIter","bandwidth","lo","hi","mid","ithDistances","nonZeroDists","interpolation","psum","exp","abs","meanIthDistances","mean","meanDistances","graphValues","entry","w","state","assign","moveOther","epochsPerNegativeSample","epochOfNextNegativeSample","epochOfNextSample","initialAlpha","alpha","gamma","current","other","distSquared","rDist","gradCoeff","gradD","clip","nNegSamples","k_1","other_1","distSquared_1","gradCoeff_1","epochCallback","epochCompleted","shouldStop","isFinished","setTimeout","err","normX","normY","clipValue","xv","linear","yv","parameterValues","default","damping","initialValues","gradientDifference","maxIterations","errorTolerance","z","input","max2d","ones","vec","vec_1","vec_1_1","item","len","toString","isAnyArray","object","endsWith","errorCalculation","parameters","parameterizedFunction","func","eye","evaluatedData","Float64Array","gradientFunc","paramFunction","ans","param","auxParams","funcParam","gradientFunction","matrixFunc","matrixFunction","inverseMatrix","mmul","sub","mul","to1DArray","levenbergMarquardt","options","minValues","maxValues","fill","parLen","Number","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","iteration","converged","isNaN","parameterError","iterations"],"sourceRoot":""}
+{"version":3,"file":"415.js","mappings":"8FACA,IA8CIA,EA9CAC,EAAmBC,MAAQA,KAAKD,kBAAqBE,OAAOC,OAAS,SAAUC,EAAGC,EAAGC,EAAGC,QAC7EC,IAAPD,IAAkBA,EAAKD,GAC3BJ,OAAOO,eAAeL,EAAGG,EAAI,CAAEG,YAAY,EAAMC,IAAK,WAAa,OAAON,EAAEC,EAAI,GACnF,EAAI,SAAUF,EAAGC,EAAGC,EAAGC,QACTC,IAAPD,IAAkBA,EAAKD,GAC3BF,EAAEG,GAAMF,EAAEC,EACb,GACGM,EAAsBX,MAAQA,KAAKW,qBAAwBV,OAAOC,OAAS,SAAUC,EAAGS,GACxFX,OAAOO,eAAeL,EAAG,UAAW,CAAEM,YAAY,EAAMI,MAAOD,GAClE,EAAI,SAAST,EAAGS,GACbT,EAAW,QAAIS,CACnB,GACIE,EAAgBd,MAAQA,KAAKc,cAAiB,SAAUC,GACxD,GAAIA,GAAOA,EAAIC,WAAY,OAAOD,EAClC,IAAIE,EAAS,CAAC,EACd,GAAW,MAAPF,EAAa,IAAK,IAAIV,KAAKU,EAAe,YAANV,GAAmBJ,OAAOiB,eAAeC,KAAKJ,EAAKV,IAAIN,EAAgBkB,EAAQF,EAAKV,GAE5H,OADAM,EAAmBM,EAAQF,GACpBE,CACX,EACIG,EAAUpB,MAAQA,KAAKoB,QAAW,SAAUjB,EAAGkB,GAC/C,IAAIjB,EAAsB,mBAAXkB,QAAyBnB,EAAEmB,OAAOC,UACjD,IAAKnB,EAAG,OAAOD,EACf,IAAmBqB,EAAYC,EAA3BC,EAAItB,EAAEe,KAAKhB,GAAOwB,EAAK,GAC3B,IACI,WAAc,IAANN,GAAgBA,KAAM,MAAQG,EAAIE,EAAEE,QAAQC,MAAMF,EAAGG,KAAKN,EAAEX,MACxE,CACA,MAAOkB,GAASN,EAAI,CAAEM,MAAOA,EAAS,CACtC,QACI,IACQP,IAAMA,EAAEK,OAASzB,EAAIsB,EAAU,SAAItB,EAAEe,KAAKO,EAClD,CACA,QAAU,GAAID,EAAG,MAAMA,EAAEM,KAAO,CACpC,CACA,OAAOJ,CACX,EACIK,EAAYhC,MAAQA,KAAKgC,UAAa,SAAS7B,GAC/C,IAAI8B,EAAsB,mBAAXX,QAAyBA,OAAOC,SAAUnB,EAAI6B,GAAK9B,EAAE8B,GAAIP,EAAI,EAC5E,GAAItB,EAAG,OAAOA,EAAEe,KAAKhB,GACrB,GAAIA,GAAyB,iBAAbA,EAAE+B,OAAqB,MAAO,CAC1CN,KAAM,WAEF,OADIzB,GAAKuB,GAAKvB,EAAE+B,SAAQ/B,OAAI,GACrB,CAAEU,MAAOV,GAAKA,EAAEuB,KAAMG,MAAO1B,EACxC,GAEJ,MAAM,IAAIgC,UAAUF,EAAI,0BAA4B,kCACxD,EAEAhC,OAAOO,eAAe4B,EAAS,aAAc,CAAEvB,OAAO,IACtDuB,EAAQC,OAASD,EAAQE,UAAYF,EAAQG,eAAiBH,EAAQI,eAAiBJ,EAAQK,QAAUL,EAAQM,SAAWN,EAAQO,IAAMP,EAAQQ,iBAAmBR,EAAQS,SAAWT,EAAQU,UAAYV,EAAQW,kBAAe,EACnO,IAAIC,EAAQlC,EAAa,EAAQ,OAC7BiC,EAAgB,WAChB,SAASA,EAAaE,EAAMC,EAAMC,EAAQC,GAItC,GAHApD,KAAKqD,QAAU,IAAIC,IACnBtD,KAAKuD,MAAQ,EACbvD,KAAKwD,MAAQ,EACTP,EAAKf,SAAWgB,EAAKhB,QAAUe,EAAKf,SAAWiB,EAAOjB,OACtD,MAAM,IAAIuB,MAAM,8DAEpBzD,KAAKuD,MAAQH,EAAK,GAClBpD,KAAKwD,MAAQJ,EAAK,GAClB,IAAK,IAAI1B,EAAI,EAAGA,EAAIyB,EAAOjB,OAAQR,IAAK,CACpC,IAAIgC,EAAMT,EAAKvB,GACXiC,EAAMT,EAAKxB,GACf1B,KAAK4D,UAAUF,EAAKC,GACpB,IAAIE,EAAM7D,KAAK8D,QAAQJ,EAAKC,GAC5B3D,KAAKqD,QAAQU,IAAIF,EAAK,CAAEhD,MAAOsC,EAAOzB,GAAIgC,IAAKA,EAAKC,IAAKA,GAC7D,CACJ,CA4FA,OA3FAZ,EAAaiB,UAAUF,QAAU,SAAUJ,EAAKC,GAC5C,OAAOD,EAAM,IAAMC,CACvB,EACAZ,EAAaiB,UAAUJ,UAAY,SAAUF,EAAKC,GAE9C,KADmBD,EAAM1D,KAAKuD,OAASI,EAAM3D,KAAKwD,OAE9C,MAAM,IAAIC,MAAM,wDAExB,EACAV,EAAaiB,UAAUD,IAAM,SAAUL,EAAKC,EAAK9C,GAC7Cb,KAAK4D,UAAUF,EAAKC,GACpB,IAAIE,EAAM7D,KAAK8D,QAAQJ,EAAKC,GACvB3D,KAAKqD,QAAQY,IAAIJ,GAIlB7D,KAAKqD,QAAQ3C,IAAImD,GAAKhD,MAAQA,EAH9Bb,KAAKqD,QAAQU,IAAIF,EAAK,CAAEhD,MAAOA,EAAO6C,IAAKA,EAAKC,IAAKA,GAK7D,EACAZ,EAAaiB,UAAUtD,IAAM,SAAUgD,EAAKC,EAAKO,QACxB,IAAjBA,IAA2BA,EAAe,GAC9ClE,KAAK4D,UAAUF,EAAKC,GACpB,IAAIE,EAAM7D,KAAK8D,QAAQJ,EAAKC,GAC5B,OAAI3D,KAAKqD,QAAQY,IAAIJ,GACV7D,KAAKqD,QAAQ3C,IAAImD,GAAKhD,MAGtBqD,CAEf,EACAnB,EAAaiB,UAAUG,OAAS,SAAUC,QACtB,IAAZA,IAAsBA,GAAU,GACpC,IAAIC,EAAe,GAcnB,OAbArE,KAAKqD,QAAQiB,SAAQ,SAAUzD,GAC3BwD,EAAavC,KAAKjB,EACtB,IACIuD,GACAC,EAAaE,MAAK,SAAUC,EAAGC,GAC3B,OAAID,EAAEd,MAAQe,EAAEf,IACLc,EAAEb,IAAMc,EAAEd,IAGVa,EAAEd,IAAMe,EAAEf,GAEzB,IAEGW,CACX,EACAtB,EAAaiB,UAAUU,QAAU,WAC7B,MAAO,CAAC1E,KAAKuD,MAAOvD,KAAKwD,MAC7B,EACAT,EAAaiB,UAAUW,QAAU,WAC7B,OAAOC,MAAMC,KAAK7E,KAAKqD,SAAS,SAAUvD,GACtC,IAAIgF,EAAK1D,EAAOtB,EAAI,GACpB,OAD8BgF,EAAG,GAAYA,EAAG,GACnCpB,GACjB,GACJ,EACAX,EAAaiB,UAAUe,QAAU,WAC7B,OAAOH,MAAMC,KAAK7E,KAAKqD,SAAS,SAAUvD,GACtC,IAAIgF,EAAK1D,EAAOtB,EAAI,GACpB,OAD8BgF,EAAG,GAAYA,EAAG,GACnCnB,GACjB,GACJ,EACAZ,EAAaiB,UAAUgB,UAAY,WAC/B,OAAOJ,MAAMC,KAAK7E,KAAKqD,SAAS,SAAUvD,GACtC,IAAIgF,EAAK1D,EAAOtB,EAAI,GACpB,OAD8BgF,EAAG,GAAYA,EAAG,GACnCjE,KACjB,GACJ,EACAkC,EAAaiB,UAAUM,QAAU,SAAUW,GACvCjF,KAAKqD,QAAQiB,SAAQ,SAAUzD,GAAS,OAAOoE,EAAGpE,EAAMA,MAAOA,EAAM6C,IAAK7C,EAAM8C,IAAM,GAC1F,EACAZ,EAAaiB,UAAUkB,IAAM,SAAUD,GACnC,IAAIE,EAAO,GACXnF,KAAKqD,QAAQiB,SAAQ,SAAUzD,GAC3BsE,EAAKrD,KAAKmD,EAAGpE,EAAMA,MAAOA,EAAM6C,IAAK7C,EAAM8C,KAC/C,IACA,IAAIP,EAAO,CAACpD,KAAKuD,MAAOvD,KAAKwD,OAC7B,OAAO,IAAIT,EAAa/C,KAAK2E,UAAW3E,KAAK+E,UAAWI,EAAM/B,EAClE,EACAL,EAAaiB,UAAUoB,QAAU,WAC7B,IAAIC,EAAQrF,KAERsF,EADOtC,EAAMuC,MAAMvF,KAAKuD,OACV2B,KAAI,WAClB,OAAOlC,EAAMwC,MAAMH,EAAM7B,MAC7B,IAIA,OAHAxD,KAAKqD,QAAQiB,SAAQ,SAAUzD,GAC3ByE,EAAOzE,EAAM6C,KAAK7C,EAAM8C,KAAO9C,EAAMA,KACzC,IACOyE,CACX,EACOvC,CACX,CA9GmB,GA+GnBX,EAAQW,aAAeA,EAavBX,EAAQU,UAZR,SAAmB2C,GACf,IAAIvC,EAAO,GACPD,EAAO,GACPkC,EAAO,GACXM,EAAOnB,SAAQ,SAAUzD,EAAO6C,EAAKC,GACjCT,EAAKpB,KAAK4B,GACVT,EAAKnB,KAAK6B,GACVwB,EAAKrD,KAAKjB,EACd,IACA,IAAIuC,EAAO,CAACqC,EAAOjC,MAAOiC,EAAOlC,OACjC,OAAO,IAAIR,EAAaE,EAAMC,EAAMiC,EAAM/B,EAC9C,EAUAhB,EAAQS,SARR,SAAkB6C,GAGd,IAFA,IAA0BzC,EAAjB7B,EAAOsE,EAAM,GAAc,GAChCD,EAAS,IAAI1C,EAAa,GAAI,GAAI,GAAI2C,GACjChE,EAAI,EAAGA,EAAIuB,EAAMvB,IACtB+D,EAAO1B,IAAIrC,EAAGA,EAAG,GAErB,OAAO+D,CACX,EAKArD,EAAQQ,iBAHR,SAA0B4B,EAAGC,GACzB,OAAOkB,EAAYnB,EAAGC,GAAG,SAAUmB,EAAGC,GAAK,OAAOD,EAAIC,CAAG,GAC7D,EAKAzD,EAAQO,IAHR,SAAa6B,EAAGC,GACZ,OAAOkB,EAAYnB,EAAGC,GAAG,SAAUmB,EAAGC,GAAK,OAAOD,EAAIC,CAAG,GAC7D,EAKAzD,EAAQM,SAHR,SAAkB8B,EAAGC,GACjB,OAAOkB,EAAYnB,EAAGC,GAAG,SAAUmB,EAAGC,GAAK,OAAOD,EAAIC,CAAG,GAC7D,EAKAzD,EAAQK,QAHR,SAAiB+B,EAAGC,GAChB,OAAOkB,EAAYnB,EAAGC,GAAG,SAAUmB,EAAGC,GAAK,OAAQD,EAAIC,EAAID,EAAIC,CAAI,GACvE,EAOAzD,EAAQI,eALR,SAAwBgC,EAAGsB,GACvB,OAAOtB,EAAEU,KAAI,SAAUrE,GACnB,OAAOA,EAAQiF,CACnB,GACJ,EAkBA1D,EAAQG,eAhBR,SAAwBnC,GAKpB,IAJA,IAAI2F,EAAc,IAAIC,IAClB7C,EAAS/C,EAAE4E,YACX/B,EAAO7C,EAAEuE,UACTzB,EAAO9C,EAAE2E,UACJrD,EAAI,EAAGA,EAAIyB,EAAOjB,OAAQR,IACb,IAAdyB,EAAOzB,IACPqE,EAAYpD,IAAIjB,GAGxB,IAAIuE,EAAoB,SAAUC,EAAGC,GAAS,OAAQJ,EAAY9B,IAAIkC,EAAQ,EAC1EC,EAAajD,EAAOkD,OAAOJ,GAC3BK,EAAWrD,EAAKoD,OAAOJ,GACvBM,EAAWrD,EAAKmD,OAAOJ,GAC3B,OAAO,IAAIlD,EAAauD,EAAUC,EAAUH,EAAYhG,EAAEsE,UAC9D,EAoCAtC,EAAQE,UAlCR,SAAmBlC,EAAGoG,GAClB,IAAIC,EAAK3G,OACQ,IAAb0G,IAAuBA,EAAW,MACtC,IAAIE,EAASC,EAAQH,GACjBI,EAAY,IAAItD,IACpBlD,EAAEkE,SAAQ,SAAU4B,EAAGxC,EAAKC,GACxB,IAAIT,EAAO0D,EAAUlG,IAAIgD,IAAQ,GACjCR,EAAKpB,KAAK6B,GACViD,EAAU7C,IAAIL,EAAKR,EACvB,IACA,IAAI2D,EAAa,IAAI9D,EAAa,GAAI,GAAI,GAAI3C,EAAEsE,WAC5CoC,EAAU,SAAUpD,GAIpB,IAHA,IAAIR,EAAO0D,EAAUlG,IAAIgD,GAAKa,OAC1BY,EAAOjC,EAAKgC,KAAI,SAAUvB,GAAO,OAAOvD,EAAEM,IAAIgD,EAAKC,EAAM,IACzDoD,EAAOL,EAAOvB,GACTzD,EAAI,EAAGA,EAAIqF,EAAK7E,OAAQR,IAC7BmF,EAAW9C,IAAIL,EAAKR,EAAKxB,GAAIqF,EAAKrF,GAE1C,EACA,IACI,IAAK,IAAIoD,EAAK9C,EAAS4E,EAAUI,QAASC,EAAKnC,EAAGlD,QAASqF,EAAGpF,KAAMoF,EAAKnC,EAAGlD,OAExEkF,EADUG,EAAGpG,MAGrB,CACA,MAAOqG,GAAST,EAAM,CAAE1E,MAAOmF,EAAS,CACxC,QACI,IACQD,IAAOA,EAAGpF,OAAS/B,EAAKgF,EAAGqC,SAASrH,EAAGqB,KAAK2D,EACpD,CACA,QAAU,GAAI2B,EAAK,MAAMA,EAAI1E,KAAO,CACxC,CACA,OAAO8E,CACX,EAEA,IAAIF,IAAW7G,EAAK,CAAC,GACT,IAAI,SAAUsH,GAElB,IADA,IAAIC,GAAM,IACD3F,EAAI,EAAGA,EAAI0F,EAAGlF,OAAQR,IAC3B2F,EAAMD,EAAG1F,GAAK2F,EAAMD,EAAG1F,GAAK2F,EAEhC,OAAOD,EAAGlC,KAAI,SAAUU,GAAK,OAAOA,EAAIyB,CAAK,GACjD,EACAvH,EAAO,GAAI,SAAUsH,GAEjB,IADA,IAAIE,EAAM,EACD5F,EAAI,EAAGA,EAAI0F,EAAGlF,OAAQR,IAC3B4F,GAAOF,EAAG1F,GAEd,OAAO0F,EAAGlC,KAAI,SAAUU,GAAK,OAAOA,EAAI0B,CAAK,GACjD,EACAxH,EAAO,GAAI,SAAUsH,GAEjB,IADA,IAAIE,EAAM,EACD5F,EAAI,EAAGA,EAAI0F,EAAGlF,OAAQR,IAC3B4F,GAAOC,KAAKC,IAAIJ,EAAG1F,GAAI,GAE3B,OAAO0F,EAAGlC,KAAI,SAAUU,GAAK,OAAO2B,KAAKE,KAAKF,KAAKC,IAAI5B,EAAG,GAAK0B,EAAM,GACzE,EACAxH,GACJ,SAAS6F,EAAYnB,EAAGC,EAAGiD,GAcvB,IAbA,IAAIC,EAAU,IAAI3B,IACd/C,EAAO,GACPC,EAAO,GACPiC,EAAO,GACPyC,EAAU,SAAUlE,EAAKC,GACzBV,EAAKnB,KAAK4B,GACVR,EAAKpB,KAAK6B,GACV,IAAIkE,EAAYH,EAAGlD,EAAE9D,IAAIgD,EAAKC,GAAMc,EAAE/D,IAAIgD,EAAKC,IAC/CwB,EAAKrD,KAAK+F,EACd,EACIC,EAAUtD,EAAEQ,YACZ+C,EAAQvD,EAAEG,UACVqD,EAAQxD,EAAEO,UACLrD,EAAI,EAAGA,EAAIoG,EAAQ5F,OAAQR,IAAK,CACrC,IAEImC,GAFAH,EAAMqE,EAAMrG,IAEA,KADZiC,EAAMqE,EAAMtG,IAEhBiG,EAAQhF,IAAIkB,GACZ+D,EAAQlE,EAAKC,EACjB,CACA,IAAIsE,EAAUxD,EAAEO,YACZkD,EAAQzD,EAAEE,UACVwD,EAAQ1D,EAAEM,UACd,IAASrD,EAAI,EAAGA,EAAIuG,EAAQ/F,OAAQR,IAAK,CACrC,IAAIgC,EACAC,EACAE,GAFAH,EAAMwE,EAAMxG,IAEA,KADZiC,EAAMwE,EAAMzG,IAEZiG,EAAQ1D,IAAIJ,IAEhB+D,EAAQlE,EAAKC,EACjB,CACA,IAAIP,EAAO,CAACoB,EAAEjB,MAAOiB,EAAEhB,OACvB,OAAO,IAAIT,EAAaE,EAAMC,EAAMiC,EAAM/B,EAC9C,CA6BAhB,EAAQC,OA5BR,SAAgBuD,GACZ,IAAIvC,EAAU,GACduC,EAAEtB,SAAQ,SAAUzD,EAAO6C,EAAKC,GAC5BN,EAAQvB,KAAK,CAAEjB,MAAOA,EAAO6C,IAAKA,EAAKC,IAAKA,GAChD,IACAN,EAAQkB,MAAK,SAAUC,EAAGC,GACtB,OAAID,EAAEd,MAAQe,EAAEf,IACLc,EAAEb,IAAMc,EAAEd,IAGVa,EAAEd,IAAMe,EAAEf,GAEzB,IAKA,IAJA,IAAI0E,EAAU,GACVjF,EAAS,GACTkF,EAAS,GACTC,GAAc,EACT5G,EAAI,EAAGA,EAAI2B,EAAQnB,OAAQR,IAAK,CACrC,IAAI5B,EAAKuD,EAAQ3B,GAAIgC,EAAM5D,EAAG4D,IAAKC,EAAM7D,EAAG6D,IAAK9C,EAAQf,EAAGe,MACxD6C,IAAQ4E,IACRA,EAAa5E,EACb2E,EAAOvG,KAAKJ,IAEhB0G,EAAQtG,KAAK6B,GACbR,EAAOrB,KAAKjB,EAChB,CACA,MAAO,CAAEuH,QAASA,EAASjF,OAAQA,EAAQkF,OAAQA,EACvD,C,uBCvVA,IAAItI,EAAmBC,MAAQA,KAAKD,kBAAqBE,OAAOC,OAAS,SAAUC,EAAGC,EAAGC,EAAGC,QAC7EC,IAAPD,IAAkBA,EAAKD,GAC3BJ,OAAOO,eAAeL,EAAGG,EAAI,CAAEG,YAAY,EAAMC,IAAK,WAAa,OAAON,EAAEC,EAAI,GACnF,EAAI,SAAUF,EAAGC,EAAGC,EAAGC,QACTC,IAAPD,IAAkBA,EAAKD,GAC3BF,EAAEG,GAAMF,EAAEC,EACb,GACGM,EAAsBX,MAAQA,KAAKW,qBAAwBV,OAAOC,OAAS,SAAUC,EAAGS,GACxFX,OAAOO,eAAeL,EAAG,UAAW,CAAEM,YAAY,EAAMI,MAAOD,GAClE,EAAI,SAAST,EAAGS,GACbT,EAAW,QAAIS,CACnB,GACIE,EAAgBd,MAAQA,KAAKc,cAAiB,SAAUC,GACxD,GAAIA,GAAOA,EAAIC,WAAY,OAAOD,EAClC,IAAIE,EAAS,CAAC,EACd,GAAW,MAAPF,EAAa,IAAK,IAAIV,KAAKU,EAAe,YAANV,GAAmBJ,OAAOiB,eAAeC,KAAKJ,EAAKV,IAAIN,EAAgBkB,EAAQF,EAAKV,GAE5H,OADAM,EAAmBM,EAAQF,GACpBE,CACX,EACAhB,OAAOO,eAAe4B,EAAS,aAAc,CAAEvB,OAAO,IACtDuB,EAAQmG,gBAAkBnG,EAAQoG,WAAapG,EAAQqG,gBAAkBrG,EAAQsG,kBAAoBtG,EAAQuG,SAAWvG,EAAQwG,gBAAkBxG,EAAQyG,cAAW,EACrK,IAAI7F,EAAQlC,EAAa,EAAQ,OACjC,SAAS+H,EAASC,EAASpD,GACvB,IAAIqD,EAAa,SAAUC,GACvB,OAAOhG,EAAMuC,MAAMuD,GAAS5D,KAAI,WAC5B,OAAOlC,EAAMiG,OAAOvD,EAAMsD,EAC9B,GACJ,EACIE,EAAO,GAIX,OAHAA,EAAKpH,KAAKiH,GAAY,IACtBG,EAAKpH,KAAKiH,EAAWI,MACrBD,EAAKpH,KAAKiH,EAAW,IACdG,CACX,CAwBA,SAASP,EAASO,EAAMxF,EAAK0F,EAAQjD,EAAOkD,GACxC3F,EAAM6D,KAAK+B,MAAM5F,GACjB,IAAI0E,EAAUc,EAAK,GAAGxF,GAClB6F,EAAUL,EAAK,GAAGxF,GAEtB,GADYwF,EAAK,GAAGxF,GAChB0F,GAAUG,EAAQ,GAClB,OAAO,EAEX,IAAK,IAAI7H,EAAI,EAAGA,EAAI0G,EAAQlG,OAAQR,IAChC,GAAIyE,IAAUiC,EAAQ1G,GAClB,OAAO,EAGf,OAAOgH,EAAkBQ,EAAMxF,EAAK0F,EAAQjD,EAAOkD,EACvD,CAEA,SAASX,EAAkBQ,EAAMxF,EAAK0F,EAAQjD,EAAOkD,GACjD,IAAIjB,EAAUc,EAAK,GAAGxF,GAClB6F,EAAUL,EAAK,GAAGxF,GAClB8F,EAAQN,EAAK,GAAGxF,GACpB,GAAI0F,GAAUG,EAAQ,GAClB,OAAO,EAEXA,EAAQ,GAAKH,EACbhB,EAAQ,GAAKjC,EACbqD,EAAM,GAAKH,EAGX,IAFA,IAAI3H,EAAI,EACJ+H,EAAQ,IACC,CACT,IAAIC,EAAM,EAAIhI,EAAI,EACdiI,EAAMD,EAAM,EACZE,EAAaV,EAAK,GAAG,GAAGhH,OAC5B,GAAIwH,GAAOE,EACP,MAEC,GAAID,GAAOC,EAAY,CACxB,KAAIL,EAAQG,GAAON,GAIf,MAHAK,EAAQC,CAKhB,MACK,GAAIH,EAAQG,IAAQH,EAAQI,GAAM,CACnC,KAAIP,EAASG,EAAQG,IAIjB,MAHAD,EAAQC,CAKhB,KACK,CACD,KAAIN,EAASG,EAAQI,IAIjB,MAHAF,EAAQE,CAKhB,CACAJ,EAAQ7H,GAAK6H,EAAQE,GACrBrB,EAAQ1G,GAAK0G,EAAQqB,GACrBD,EAAM9H,GAAK8H,EAAMC,GACjB/H,EAAI+H,CACR,CAIA,OAHAF,EAAQ7H,GAAK0H,EACbhB,EAAQ1G,GAAKyE,EACbqD,EAAM9H,GAAK2H,EACJ,CACX,CAyCA,SAASQ,EAASC,EAAOC,EAAOC,EAASC,GACrC,KAAa,EAANA,EAAU,EAAID,GAAS,CAC1B,IAAIE,EAAkB,EAAND,EAAU,EACtBE,EAAaD,EAAY,EACzBE,EAAOH,EAOX,GANIH,EAAMM,GAAQN,EAAMI,KACpBE,EAAOF,GAEPC,EAAaH,GAAWF,EAAMM,GAAQN,EAAMK,KAC5CC,EAAOD,GAEPC,IAASH,EACT,MAGA,IAAII,EAAQP,EAAMG,GAClBH,EAAMG,GAAOH,EAAMM,GACnBN,EAAMM,GAAQC,EACd,IAAIC,EAAQP,EAAME,GAClBF,EAAME,GAAOF,EAAMK,GACnBL,EAAMK,GAAQE,EACdL,EAAMG,CAEd,CACJ,CA5JAhI,EAAQyG,SAAWA,EAsBnBzG,EAAQwG,gBArBR,SAAyB2B,EAAUC,EAAUC,GAEzC,IADA,IAAIxJ,EAAS+B,EAAMwC,MAAM+E,GAChB7I,EAAI,EAAGA,EAAI6I,EAAU7I,IAAK,CAG/B,IAFA,IAAIgJ,GAAe,EACfC,EAAI,EACDD,GAAc,CACjBC,EAAI3H,EAAM4H,WAAWJ,EAAUC,GAE/B,IADA,IAAII,GAAS,EACJxK,EAAI,EAAGA,EAAIqB,EAAGrB,IACnB,GAAIsK,IAAM1J,EAAOZ,GAAI,CACjBwK,GAAS,EACT,KACJ,CAECA,IACDH,GAAe,EACvB,CACAzJ,EAAOS,GAAKiJ,CAChB,CACA,OAAO1J,CACX,EAiBAmB,EAAQuG,SAAWA,EAsDnBvG,EAAQsG,kBAAoBA,EAkB5BtG,EAAQqG,gBAjBR,SAAyBqC,EAAcC,EAAWC,EAAYC,EAAeR,GAEzE,IADA,IAAIS,EAAqBrC,EAASkC,EAAWE,GACpCvJ,EAAI,EAAGA,EAAIqJ,EAAWrJ,IAC3B,IAAK,IAAIiJ,EAAI,EAAGA,EAAIK,EAAYL,IAC5B,KAAIG,EAAa,GAAGpJ,GAAGiJ,GAAK,GAA5B,CAGA,IAAIQ,EAAML,EAAa,GAAGpJ,GAAGiJ,GACzBS,EAAMN,EAAa,GAAGpJ,GAAGiJ,GACzBU,EAAIrI,EAAMsI,QAAQb,GACtB9B,EAASuC,EAAoBxJ,EAAG2J,EAAGF,EAAKC,GACxCzC,EAASuC,EAAoBC,EAAKE,EAAG3J,EAAG0J,GACxCN,EAAa,GAAGpJ,GAAGiJ,GAAK,CANxB,CASR,OAAOO,CACX,EAsBA9I,EAAQoG,WApBR,SAAoBU,GAGhB,IAFA,IAAId,EAAUc,EAAK,GACfK,EAAUL,EAAK,GACVxH,EAAI,EAAGA,EAAI0G,EAAQlG,OAAQR,IAGhC,IAFA,IAAI6J,EAAUnD,EAAQ1G,GAClB8J,EAAWjC,EAAQ7H,GACdiJ,EAAI,EAAGA,EAAIY,EAAQrJ,OAAS,EAAGyI,IAAK,CACzC,IAAIc,EAAeF,EAAQrJ,OAASyI,EAAI,EACpCe,EAAgBF,EAAStJ,OAASyI,EAAI,EACtCN,EAAQkB,EAAQ,GACpBA,EAAQ,GAAKA,EAAQE,GACrBF,EAAQE,GAAgBpB,EACxB,IAAIC,EAAQkB,EAAS,GACrBA,EAAS,GAAKA,EAASE,GACvBF,EAASE,GAAiBpB,EAC1BT,EAAS2B,EAAUD,EAASG,EAAe,EAC/C,CAEJ,MAAO,CAAEtD,QAASA,EAASmB,QAASA,EACxC,EA+CAnH,EAAQmG,gBApBR,SAAyBW,EAAMxF,GAM3B,IALA,IAAIiI,EAAMzC,EAAK,GAAGxF,GACdkI,EAAO1C,EAAK,GAAGxF,GACf2F,EAAOH,EAAK,GAAGxF,GACfmI,EAAU1C,IACV2C,GAAe,EACVpK,EAAI,EAAGA,EAAIiK,EAAIzJ,OAAQR,IACZ,IAAZ2H,EAAK3H,IAAYkK,EAAKlK,GAAKmK,IAC3BA,EAAUD,EAAKlK,GACfoK,EAAcpK,GAGtB,OAAIoK,GAAe,GACfzC,EAAKyC,GAAe,EACbvE,KAAK+B,MAAMqC,EAAIG,MAGd,CAEhB,C,uBClNA,IAAI/L,EAAmBC,MAAQA,KAAKD,kBAAqBE,OAAOC,OAAS,SAAUC,EAAGC,EAAGC,EAAGC,QAC7EC,IAAPD,IAAkBA,EAAKD,GAC3BJ,OAAOO,eAAeL,EAAGG,EAAI,CAAEG,YAAY,EAAMC,IAAK,WAAa,OAAON,EAAEC,EAAI,GACnF,EAAI,SAAUF,EAAGC,EAAGC,EAAGC,QACTC,IAAPD,IAAkBA,EAAKD,GAC3BF,EAAEG,GAAMF,EAAEC,EACb,GACGM,EAAsBX,MAAQA,KAAKW,qBAAwBV,OAAOC,OAAS,SAAUC,EAAGS,GACxFX,OAAOO,eAAeL,EAAG,UAAW,CAAEM,YAAY,EAAMI,MAAOD,GAClE,EAAI,SAAST,EAAGS,GACbT,EAAW,QAAIS,CACnB,GACIE,EAAgBd,MAAQA,KAAKc,cAAiB,SAAUC,GACxD,GAAIA,GAAOA,EAAIC,WAAY,OAAOD,EAClC,IAAIE,EAAS,CAAC,EACd,GAAW,MAAPF,EAAa,IAAK,IAAIV,KAAKU,EAAe,YAANV,GAAmBJ,OAAOiB,eAAeC,KAAKJ,EAAKV,IAAIN,EAAgBkB,EAAQF,EAAKV,GAE5H,OADAM,EAAmBM,EAAQF,GACpBE,CACX,EACIe,EAAYhC,MAAQA,KAAKgC,UAAa,SAAS7B,GAC/C,IAAI8B,EAAsB,mBAAXX,QAAyBA,OAAOC,SAAUnB,EAAI6B,GAAK9B,EAAE8B,GAAIP,EAAI,EAC5E,GAAItB,EAAG,OAAOA,EAAEe,KAAKhB,GACrB,GAAIA,GAAyB,iBAAbA,EAAE+B,OAAqB,MAAO,CAC1CN,KAAM,WAEF,OADIzB,GAAKuB,GAAKvB,EAAE+B,SAAQ/B,OAAI,GACrB,CAAEU,MAAOV,GAAKA,EAAEuB,KAAMG,MAAO1B,EACxC,GAEJ,MAAM,IAAIgC,UAAUF,EAAI,0BAA4B,kCACxD,EACAhC,OAAOO,eAAe4B,EAAS,aAAc,CAAEvB,OAAO,IACtDuB,EAAQ2J,iBAAmB3J,EAAQ4J,wBAA0B5J,EAAQ6J,oBAAsB7J,EAAQ8J,mBAAgB,EACnH,IAAIhD,EAAOpI,EAAa,EAAQ,OAC5B2E,EAAS3E,EAAa,EAAQ,MAC9BqL,EAAOrL,EAAa,EAAQ,OAC5BkC,EAAQlC,EAAa,EAAQ,OAiEjCsB,EAAQ8J,cAhER,SAAuBE,EAAY3B,GAC/B,OAAO,SAAmB4B,EAAMC,EAAWtB,EAAYuB,EAAQtB,EAAeuB,EAAOC,EAAKC,QACvE,IAAXH,IAAqBA,EAAS,SACZ,IAAlBtB,IAA4BA,EAAgB,SAClC,IAAVuB,IAAoBA,EAAQ,WACpB,IAARC,IAAkBA,EAAM,SACT,IAAfC,IAAyBA,GAAa,GAG1C,IAFA,IAAI3B,EAAYsB,EAAKnK,OACjB4I,EAAe5B,EAAKL,SAASwD,EAAKnK,OAAQ8I,GACrCtJ,EAAI,EAAGA,EAAI2K,EAAKnK,OAAQR,IAE7B,IADA,IAAI0G,EAAUc,EAAKN,gBAAgBoC,EAAYqB,EAAKnK,OAAQuI,GACnDE,EAAI,EAAGA,EAAIvC,EAAQlG,OAAQyI,IAAK,CACrC,IAAIU,EAAIe,EAAWC,EAAK3K,GAAI2K,EAAKjE,EAAQuC,KACzCzB,EAAKP,SAASmC,EAAcpJ,EAAG2J,EAAGjD,EAAQuC,GAAI,GAC9CzB,EAAKP,SAASmC,EAAc1C,EAAQuC,GAAIU,EAAG3J,EAAG,EAClD,CAEJ,GAAIgL,EACA,IAAK,IAAIrL,EAAI,EAAGA,EAAIiL,EAAUpK,OAAQb,IAClC,IAASK,EAAI,EAAGA,EAAI4K,EAAUjL,GAAGa,UACzBoK,EAAUjL,GAAGK,GAAK,GADeA,IAIrC,IAASiJ,EAAIjJ,EAAI,EAAGiJ,EAAI2B,EAAUjL,GAAGa,UAC7BoK,EAAUjL,GAAGsJ,GAAK,GADmBA,IAIrCU,EAAIe,EAAWC,EAAKC,EAAUjL,GAAGK,IAAK2K,EAAKC,EAAUjL,GAAGsJ,KAC5DzB,EAAKP,SAASmC,EAAcwB,EAAUjL,GAAGK,GAAI2J,EAAGiB,EAAUjL,GAAGsJ,GAAI,GACjEzB,EAAKP,SAASmC,EAAcwB,EAAUjL,GAAGsJ,GAAIU,EAAGiB,EAAUjL,GAAGK,GAAI,GAKjF,IAASL,EAAI,EAAGA,EAAIkL,EAAQlL,IAAK,CAC7B,IAAI6J,EAAqBhC,EAAKT,gBAAgBqC,EAAcC,EAAWC,EAAYC,EAAeR,GAC9FkC,EAAI,EACR,IAASjL,EAAI,EAAGA,EAAIqJ,EAAWrJ,IAC3B,IAASiJ,EAAI,EAAGA,EAAIM,EAAeN,IAAK,CACpC,IAAIiC,EAAIrF,KAAK+B,MAAM4B,EAAmB,GAAGxJ,GAAGiJ,IAC5C,KAAIiC,EAAI,GAAK5J,EAAMsI,QAAQb,GAAUgC,GAGrC,IAAK,IAAIpM,EAAI,EAAGA,EAAI4K,EAAe5K,IAAK,CACpC,IAAIwM,EAAItF,KAAK+B,MAAM4B,EAAmB,GAAGxJ,GAAGrB,IACxCyM,EAAK5B,EAAmB,GAAGxJ,GAAGiJ,GAC9BoC,EAAK7B,EAAmB,GAAGxJ,GAAGrB,GAC9BwM,EAAI,IAAOC,IAAOC,IAGlB1B,EAAIe,EAAWC,EAAKO,GAAIP,EAAKQ,IACjCF,GAAKzD,EAAKP,SAASmC,EAAc8B,EAAGvB,EAAGwB,EAAG,GAC1CF,GAAKzD,EAAKP,SAASmC,EAAc+B,EAAGxB,EAAGuB,EAAG,GAC9C,CACJ,CAEJ,GAAID,GAAKH,EAAQxB,EAAaqB,EAAKnK,OAC/B,KAER,CAEA,OADagH,EAAKV,WAAWsC,EAEjC,CACJ,EA8BA1I,EAAQ6J,oBA5BR,SAA6BG,GA0BzB,MAAO,CAAEY,eAzBT,SAAwBhC,EAAYqB,EAAMY,EAAaC,EAAOzC,GAC1D,IAAK,IAAI/I,EAAI,EAAGA,EAAIuL,EAAY/K,OAAQR,IAEpC,IADA,IAAI0G,EAAUpF,EAAM4F,gBAAgBoC,EAAYqB,EAAKnK,OAAQuI,GACpDE,EAAI,EAAGA,EAAIvC,EAAQlG,OAAQyI,IAChC,KAAIvC,EAAQuC,GAAK,GAAjB,CAGA,IAAIU,EAAIe,EAAWC,EAAKjE,EAAQuC,IAAKsC,EAAYvL,IACjDwH,EAAKP,SAASuE,EAAOxL,EAAG2J,EAAGjD,EAAQuC,GAAI,EAFvC,CAKZ,EAcyCwC,aAbzC,SAAsBC,EAAOf,EAAMY,EAAaC,EAAOzC,GACnD,IAAK,IAAI/I,EAAI,EAAGA,EAAIuL,EAAY/K,OAAQR,IAEpC,IADA,IAAI0G,EAAU+D,EAAKkB,eAAeJ,EAAYvL,GAAI0L,EAAO3C,GAChDE,EAAI,EAAGA,EAAIvC,EAAQlG,OAAQyI,IAAK,CACrC,GAAIvC,EAAQuC,GAAK,EACb,OAEJ,IAAIU,EAAIe,EAAWC,EAAKjE,EAAQuC,IAAKsC,EAAYvL,IACjDwH,EAAKP,SAASuE,EAAOxL,EAAG2J,EAAGjD,EAAQuC,GAAI,EAC3C,CAGR,EAEJ,EAuCAvI,EAAQ4J,wBArCR,SAAiCI,GAC7B,OAAO,SAAoBC,EAAMiB,EAAOC,EAAgBN,GAGpD,IAFA,IAAIxG,EAAK3G,EACLgF,EAAKW,EAAOpD,OAAOiL,GAAQlF,EAAUtD,EAAGsD,QAASC,EAASvD,EAAGuD,OACxD3G,EAAI,EAAGA,EAAIuL,EAAY/K,OAAQR,IAEpC,IADA,IAAI8L,EAAQ,IAAIxH,IAAIuH,EAAe,GAAG7L,MACzB,CACT,IAAI+L,EAASvE,EAAKX,gBAAgBgF,EAAgB7L,GAClD,IAAgB,IAAZ+L,EACA,MAEJ,IAAIC,EAAatF,EAAQuF,MAAMtF,EAAOoF,GAASpF,EAAOoF,EAAS,IAC/D,IACI,IAAK,IAAIG,GAAgBnH,OAAM,EAAQzE,EAAS0L,IAAcG,EAAiBD,EAAahM,QAASiM,EAAehM,KAAMgM,EAAiBD,EAAahM,OAAQ,CAC5J,IAAIkM,EAAYD,EAAehN,MAC/B,GAAIiN,IAAcL,IACC,IAAfK,IACAN,EAAMvJ,IAAI6J,GAFd,CAKA,IAAIzC,EAAIe,EAAWC,EAAKyB,GAAYb,EAAYvL,IAChDwH,EAAKR,kBAAkB6E,EAAgB7L,EAAG2J,EAAGyC,EAAW,GACxDN,EAAM7K,IAAImL,EAHV,CAIJ,CACJ,CACA,MAAO5G,GAAST,EAAM,CAAE1E,MAAOmF,EAAS,CACxC,QACI,IACQ2G,IAAmBA,EAAehM,OAAS/B,EAAK8N,EAAazG,SAASrH,EAAGqB,KAAKyM,EACtF,CACA,QAAU,GAAInH,EAAK,MAAMA,EAAI1E,KAAO,CACxC,CACJ,CAEJ,OAAOwL,CACX,CACJ,EAuBAnL,EAAQ2J,iBArBR,SAA0BgC,EAAQ1B,EAAMY,EAAajC,EAAYgC,EAAgBG,EAAc1C,GAC3F,IAAIuD,EAAKlO,EACLmO,EAAU/E,EAAKL,SAASoE,EAAY/K,OAAQ8I,GAEhD,GADAgC,EAAehC,EAAYqB,EAAMY,EAAagB,EAASxD,GACnDsD,EACA,IACI,IAAK,IAAIG,EAAWlM,EAAS+L,GAASI,EAAaD,EAAStM,QAASuM,EAAWtM,KAAMsM,EAAaD,EAAStM,OAExGuL,EADagB,EAAWtN,MACHwL,EAAMY,EAAagB,EAASxD,EAEzD,CACA,MAAO2D,GAASJ,EAAM,CAAEjM,MAAOqM,EAAS,CACxC,QACI,IACQD,IAAeA,EAAWtM,OAAS/B,EAAKoO,EAAS/G,SAASrH,EAAGqB,KAAK+M,EAC1E,CACA,QAAU,GAAIF,EAAK,MAAMA,EAAIjM,KAAO,CACxC,CAEJ,OAAOkM,CACX,C,iBC3LA,IAAII,EAAS,EAAQ,MACrBpO,OAAOO,eAAe4B,EAAS,IAA/B,CAAyC3B,YAAY,EAAMC,IAAK,WAAc,OAAO2N,EAAOC,IAAM,G,uBCFlG,IAAIvO,EAAmBC,MAAQA,KAAKD,kBAAqBE,OAAOC,OAAS,SAAUC,EAAGC,EAAGC,EAAGC,QAC7EC,IAAPD,IAAkBA,EAAKD,GAC3BJ,OAAOO,eAAeL,EAAGG,EAAI,CAAEG,YAAY,EAAMC,IAAK,WAAa,OAAON,EAAEC,EAAI,GACnF,EAAI,SAAUF,EAAGC,EAAGC,EAAGC,QACTC,IAAPD,IAAkBA,EAAKD,GAC3BF,EAAEG,GAAMF,EAAEC,EACb,GACGM,EAAsBX,MAAQA,KAAKW,qBAAwBV,OAAOC,OAAS,SAAUC,EAAGS,GACxFX,OAAOO,eAAeL,EAAG,UAAW,CAAEM,YAAY,EAAMI,MAAOD,GAClE,EAAI,SAAST,EAAGS,GACbT,EAAW,QAAIS,CACnB,GACIE,EAAgBd,MAAQA,KAAKc,cAAiB,SAAUC,GACxD,GAAIA,GAAOA,EAAIC,WAAY,OAAOD,EAClC,IAAIE,EAAS,CAAC,EACd,GAAW,MAAPF,EAAa,IAAK,IAAIV,KAAKU,EAAe,YAANV,GAAmBJ,OAAOiB,eAAeC,KAAKJ,EAAKV,IAAIN,EAAgBkB,EAAQF,EAAKV,GAE5H,OADAM,EAAmBM,EAAQF,GACpBE,CACX,EACIG,EAAUpB,MAAQA,KAAKoB,QAAW,SAAUjB,EAAGkB,GAC/C,IAAIjB,EAAsB,mBAAXkB,QAAyBnB,EAAEmB,OAAOC,UACjD,IAAKnB,EAAG,OAAOD,EACf,IAAmBqB,EAAYC,EAA3BC,EAAItB,EAAEe,KAAKhB,GAAOwB,EAAK,GAC3B,IACI,WAAc,IAANN,GAAgBA,KAAM,MAAQG,EAAIE,EAAEE,QAAQC,MAAMF,EAAGG,KAAKN,EAAEX,MACxE,CACA,MAAOkB,GAASN,EAAI,CAAEM,MAAOA,EAAS,CACtC,QACI,IACQP,IAAMA,EAAEK,OAASzB,EAAIsB,EAAU,SAAItB,EAAEe,KAAKO,EAClD,CACA,QAAU,GAAID,EAAG,MAAMA,EAAEM,KAAO,CACpC,CACA,OAAOJ,CACX,EACI4M,EAAYvO,MAAQA,KAAKuO,UAAa,WACtC,IAAK,IAAI5M,EAAK,GAAID,EAAI,EAAGA,EAAI8M,UAAUtM,OAAQR,IAAKC,EAAKA,EAAG8M,OAAOrN,EAAOoN,UAAU9M,KACpF,OAAOC,CACX,EACIK,EAAYhC,MAAQA,KAAKgC,UAAa,SAAS7B,GAC/C,IAAI8B,EAAsB,mBAAXX,QAAyBA,OAAOC,SAAUnB,EAAI6B,GAAK9B,EAAE8B,GAAIP,EAAI,EAC5E,GAAItB,EAAG,OAAOA,EAAEe,KAAKhB,GACrB,GAAIA,GAAyB,iBAAbA,EAAE+B,OAAqB,MAAO,CAC1CN,KAAM,WAEF,OADIzB,GAAKuB,GAAKvB,EAAE+B,SAAQ/B,OAAI,GACrB,CAAEU,MAAOV,GAAKA,EAAEuB,KAAMG,MAAO1B,EACxC,GAEJ,MAAM,IAAIgC,UAAUF,EAAI,0BAA4B,kCACxD,EACAhC,OAAOO,eAAe4B,EAAS,aAAc,CAAEvB,OAAO,IACtDuB,EAAQiL,eAAiBjL,EAAQsM,cAAgBtM,EAAQuM,WAAavM,EAAQwM,cAAW,EACzF,IAAI5L,EAAQlC,EAAa,EAAQ,OAC7B8N,EACA,SAAkBC,EAAaC,EAASC,EAAU3G,GAC9CpI,KAAK6O,YAAcA,EACnB7O,KAAK8O,QAAUA,EACf9O,KAAK+O,SAAWA,EAChB/O,KAAKoI,QAAUA,CACnB,EAmBJ,SAAS4G,EAAkB3C,EAAMjE,EAAS6G,EAAUpC,EAAGpC,GAEnD,QADiB,IAAbwE,IAAuBA,EAAW,IAClC7G,EAAQlG,OAAS+M,EAAU,CAC3B,IAAIC,EAYZ,SAAwC7C,EAAMjE,EAASqC,GACnD,IAAI0E,EAAM9C,EAAK,GAAGnK,OACdkN,EAAYpM,EAAM4H,WAAWxC,EAAQlG,OAAQuI,GAC7C4E,EAAarM,EAAM4H,WAAWxC,EAAQlG,OAAQuI,GAElD4E,GADAA,GAAcD,IAAcC,EAAa,EAAI,GACnBjH,EAAQlG,OAKlC,IAJA,IAAIoN,EAAOlH,EAAQgH,GACfG,EAAQnH,EAAQiH,GAChBG,EAAmB,EACnBC,EAAmBzM,EAAMwC,MAAM2J,GAC1BzN,EAAI,EAAGA,EAAI+N,EAAiBvN,OAAQR,IACzC+N,EAAiB/N,GAAK2K,EAAKiD,GAAM5N,GAAK2K,EAAKkD,GAAO7N,GAClD8N,GACKC,EAAiB/N,IAAM2K,EAAKiD,GAAM5N,GAAK2K,EAAKkD,GAAO7N,IAAO,EAEnE,IAAIgO,EAAQ,EACRC,EAAS,EACTC,EAAO5M,EAAMwC,MAAM4C,EAAQlG,QAC/B,IAASR,EAAI,EAAGA,EAAI0G,EAAQlG,OAAQR,IAAK,CAErC,IADA,IAAImO,EAASL,EACJnE,EAAI,EAAGA,EAAI8D,EAAK9D,IACrBwE,GAAUJ,EAAiBpE,GAAKgB,EAAKjE,EAAQ1G,IAAI2J,GAEtC,IAAXwE,GACAD,EAAKlO,GAAKsB,EAAM4H,WAAW,EAAGH,GACd,IAAZmF,EAAKlO,GACLgO,GAAS,EAGTC,GAAU,GAGTE,EAAS,GACdD,EAAKlO,GAAK,EACVgO,GAAS,IAGTE,EAAKlO,GAAK,EACViO,GAAU,EAElB,CACA,IAAIG,EAAc9M,EAAMwC,MAAMkK,GAC1BK,EAAe/M,EAAMwC,MAAMmK,GAG/B,IAFAD,EAAQ,EACRC,EAAS,EACAjO,EAAI,EAAGA,EAAIkO,EAAK1N,OAAQR,IACb,IAAZkO,EAAKlO,IACLoO,EAAYJ,GAAStH,EAAQ1G,GAC7BgO,GAAS,IAGTK,EAAaJ,GAAUvH,EAAQ1G,GAC/BiO,GAAU,GAGlB,MAAO,CACHG,YAAaA,EACbC,aAAcA,EACdC,WAAYP,EACZQ,OAAQT,EAEhB,CAzE2BU,CAA+B7D,EAAMjE,EAASqC,GAC7DqF,EAAcZ,EAAaY,YAAaC,EAAeb,EAAaa,aAAcC,EAAad,EAAac,WAAYC,EAASf,EAAae,OAIlJ,MADW,CAAE/F,UAFG8E,EAAkB3C,EAAMyD,EAAab,EAAUpC,EAAI,EAAGpC,GAEnCN,WADlB6E,EAAkB3C,EAAM0D,EAAcd,EAAUpC,EAAI,EAAGpC,GACb0F,QAAQ,EAAOH,WAAYA,EAAYC,OAAQA,EAE9G,CAGI,MADW,CAAE7H,QAASA,EAAS+H,QAAQ,EAG/C,CA6EA,SAASC,EAAiBjE,EAAM0C,EAAaC,EAASC,EAAU3G,EAASiI,EAASC,GAC9E,IAAIxQ,EACJ,GAAIqM,EAAKgE,OAIL,OAHApB,EAASsB,GAAS,IAAMC,GACvBxQ,EAAKsI,EAAQkI,IAAUC,OAAOC,MAAM1Q,EAAIyO,EAAS,CAAC,EAAGpC,EAAK/D,QAAQlG,QAASiK,EAAK/D,UAE1E,CAAEiI,QAASA,EAASC,QAD3BA,GAAW,GAIXzB,EAAYwB,GAAWlE,EAAK6D,WAC5BlB,EAAQuB,GAAWlE,EAAK8D,OACxBlB,EAASsB,GAAS,GAAKA,EAAU,EACjC,IAAII,EAAaJ,EACbK,EAAMN,EAAiBjE,EAAKjC,UAAW2E,EAAaC,EAASC,EAAU3G,EAASiI,EAAU,EAAGC,GAKjG,OAJAD,EAAUK,EAAIL,QACdC,EAAUI,EAAIJ,QACdvB,EAAS0B,GAAY,GAAKJ,EAAU,EAE7B,CAAEA,SADTK,EAAMN,EAAiBjE,EAAKhC,WAAY0E,EAAaC,EAASC,EAAU3G,EAASiI,EAAU,EAAGC,IACxED,QAASC,QAASI,EAAIJ,QAEpD,CACA,SAASK,EAASxE,GACd,OAAIA,EAAKgE,OACE,EAGA,EAAIQ,EAASxE,EAAKjC,WAAayG,EAASxE,EAAKhC,WAE5D,CACA,SAASyG,EAAUzE,GACf,OAAIA,EAAKgE,OACE,EAGAS,EAAUzE,EAAKjC,WAAa0G,EAAUzE,EAAKhC,WAE1D,CAyBA,SAAS0G,EAAWb,EAAYC,EAAQa,EAAOrG,GAE3C,IADA,IAAIoF,EAASI,EACJ5E,EAAI,EAAGA,EAAIyF,EAAM5O,OAAQmJ,IAC9BwE,GAAUG,EAAW3E,GAAKyF,EAAMzF,GAEpC,OAAe,IAAXwE,EACW7M,EAAM4H,WAAW,EAAGH,GAG1BoF,EAAS,EACP,EAGA,CAEf,CAvLAzN,EAAQwM,SAAWA,EASnBxM,EAAQuM,WARR,SAAoBtC,EAAMrB,EAAY+F,EAAQtG,GAC1C,IAAIwE,EAAW1H,KAAKF,IAAI,GAAI2D,GAK5B,OAJYhI,EACPgO,MAAMD,GACN7L,KAAI,SAAUgB,EAAGxE,GAAK,OAK/B,SAAkB2K,EAAM4C,EAAU5N,EAAGoJ,GAIjC,YAHiB,IAAbwE,IAAuBA,EAAW,IAE3BD,EAAkB3C,EADfrJ,EAAMgO,MAAM3E,EAAKnK,QACa+M,EAAU5N,EAAGoJ,EAE7D,CAVsCwG,CAAS5E,EAAM4C,EAAUvN,EAAG+I,EAAS,IACpDvF,KAAI,SAAUiH,GAAQ,OAuF7C,SAAqBA,EAAM8C,GACvB,IAAIiC,EAASP,EAASxE,GAClBgF,EAAUP,EAAUzE,GACpB0C,EAAc7L,EACbgO,MAAME,GACNhM,KAAI,WAAc,OAAOlC,EAAMwC,MAAM2G,EAAK6D,WAAa7D,EAAK6D,WAAW9N,OAAS,EAAI,IACrF4M,EAAU9L,EAAMwC,MAAM0L,GACtBnC,EAAW/L,EAAMgO,MAAME,GAAQhM,KAAI,WAAc,MAAO,EAAE,GAAI,EAAI,IAClEkD,EAAUpF,EACTgO,MAAMG,GACNjM,KAAI,WAAc,OAAOlC,EAAMgO,MAAM/B,GAAU/J,KAAI,WAAc,OAAQ,CAAG,GAAI,IAErF,OADAkL,EAAiBjE,EAAM0C,EAAaC,EAASC,EAAU3G,EAAS,EAAG,GAC5D,IAAIwG,EAASC,EAAaC,EAASC,EAAU3G,EACxD,CApGoDgJ,CAAYjF,EAAM8C,EAAW,GAEjF,EA+JA7M,EAAQsM,cAvBR,SAAuB2C,GACnB,IAAI5K,EAAK3G,EACT,GAAIuR,EAASnP,OAAS,EAAG,CACrB,IAAIoD,EAAS,GACb,IACI,IAAK,IAAIgM,EAAatP,EAASqP,GAAWE,EAAeD,EAAW1P,QAAS2P,EAAa1P,KAAM0P,EAAeD,EAAW1P,OAAQ,CAC9H,IAAIuK,EAAOoF,EAAa1Q,MACxByE,EAAOxD,KAAK0O,MAAMlL,EAAQiJ,EAASpC,EAAK/D,SAC5C,CACJ,CACA,MAAOlB,GAAST,EAAM,CAAE1E,MAAOmF,EAAS,CACxC,QACI,IACQqK,IAAiBA,EAAa1P,OAAS/B,EAAKwR,EAAWnK,SAASrH,EAAGqB,KAAKmQ,EAChF,CACA,QAAU,GAAI7K,EAAK,MAAMA,EAAI1E,KAAO,CACxC,CACA,OAAOuD,CACX,CAEI,MAAO,CAAC,EAAE,GAElB,EAgCAlD,EAAQiL,eAdR,SAAwByD,EAAO3E,EAAM1B,GAEjC,IADA,IAAI+G,EAAO,EACJrF,EAAK4C,SAASyC,GAAM,GAAK,GAGxBA,EADS,IADFX,EAAW1E,EAAK0C,YAAY2C,GAAOrF,EAAK2C,QAAQ0C,GAAOV,EAAOrG,GAE9D0B,EAAK4C,SAASyC,GAAM,GAGpBrF,EAAK4C,SAASyC,GAAM,GAGnC,IAAIrL,GAAS,EAAIgG,EAAK4C,SAASyC,GAAM,GACrC,OAAOrF,EAAK/D,QAAQjC,EACxB,C,uBCnQA,IAAIpG,EAAmBC,MAAQA,KAAKD,kBAAqBE,OAAOC,OAAS,SAAUC,EAAGC,EAAGC,EAAGC,QAC7EC,IAAPD,IAAkBA,EAAKD,GAC3BJ,OAAOO,eAAeL,EAAGG,EAAI,CAAEG,YAAY,EAAMC,IAAK,WAAa,OAAON,EAAEC,EAAI,GACnF,EAAI,SAAUF,EAAGC,EAAGC,EAAGC,QACTC,IAAPD,IAAkBA,EAAKD,GAC3BF,EAAEG,GAAMF,EAAEC,EACb,GACGM,EAAsBX,MAAQA,KAAKW,qBAAwBV,OAAOC,OAAS,SAAUC,EAAGS,GACxFX,OAAOO,eAAeL,EAAG,UAAW,CAAEM,YAAY,EAAMI,MAAOD,GAClE,EAAI,SAAST,EAAGS,GACbT,EAAW,QAAIS,CACnB,GACIE,EAAgBd,MAAQA,KAAKc,cAAiB,SAAUC,GACxD,GAAIA,GAAOA,EAAIC,WAAY,OAAOD,EAClC,IAAIE,EAAS,CAAC,EACd,GAAW,MAAPF,EAAa,IAAK,IAAIV,KAAKU,EAAe,YAANV,GAAmBJ,OAAOiB,eAAeC,KAAKJ,EAAKV,IAAIN,EAAgBkB,EAAQF,EAAKV,GAE5H,OADAM,EAAmBM,EAAQF,GACpBE,CACX,EACIwQ,EAAazR,MAAQA,KAAKyR,WAAc,SAAUC,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAIE,WAAU,SAAUC,EAASC,GAC/C,SAASC,EAAUpR,GAAS,IAAMqR,EAAKL,EAAUjQ,KAAKf,GAAS,CAAE,MAAOY,GAAKuQ,EAAOvQ,EAAI,CAAE,CAC1F,SAAS0Q,EAAStR,GAAS,IAAMqR,EAAKL,EAAiB,MAAEhR,GAAS,CAAE,MAAOY,GAAKuQ,EAAOvQ,EAAI,CAAE,CAC7F,SAASyQ,EAAKjR,GAJlB,IAAeJ,EAIaI,EAAOY,KAAOkQ,EAAQ9Q,EAAOJ,QAJ1CA,EAIyDI,EAAOJ,MAJhDA,aAAiB+Q,EAAI/Q,EAAQ,IAAI+Q,GAAE,SAAUG,GAAWA,EAAQlR,EAAQ,KAIjBuR,KAAKH,EAAWE,EAAW,CAC7GD,GAAML,EAAYA,EAAUrB,MAAMkB,EAASC,GAAc,KAAK/P,OAClE,GACJ,EACIyQ,EAAerS,MAAQA,KAAKqS,aAAgB,SAAUX,EAASY,GAC/D,IAAsGC,EAAG1M,EAAG2M,EAAGC,EAA3GvM,EAAI,CAAEwM,MAAO,EAAGC,KAAM,WAAa,GAAW,EAAPH,EAAE,GAAQ,MAAMA,EAAE,GAAI,OAAOA,EAAE,EAAI,EAAGI,KAAM,GAAIC,IAAK,IAChG,OAAOJ,EAAI,CAAE7Q,KAAMkR,EAAK,GAAI,MAASA,EAAK,GAAI,OAAUA,EAAK,IAAwB,mBAAXxR,SAA0BmR,EAAEnR,OAAOC,UAAY,WAAa,OAAOvB,IAAM,GAAIyS,EACvJ,SAASK,EAAKzR,GAAK,OAAO,SAAUT,GAAK,OACzC,SAAc8G,GACV,GAAI6K,EAAG,MAAM,IAAIpQ,UAAU,mCAC3B,KAAO+D,OACH,GAAIqM,EAAI,EAAG1M,IAAM2M,EAAY,EAAR9K,EAAG,GAAS7B,EAAU,OAAI6B,EAAG,GAAK7B,EAAS,SAAO2M,EAAI3M,EAAU,SAAM2M,EAAErR,KAAK0E,GAAI,GAAKA,EAAEjE,SAAW4Q,EAAIA,EAAErR,KAAK0E,EAAG6B,EAAG,KAAK7F,KAAM,OAAO2Q,EAE3J,OADI3M,EAAI,EAAG2M,IAAG9K,EAAK,CAAS,EAARA,EAAG,GAAQ8K,EAAE3R,QACzB6G,EAAG,IACP,KAAK,EAAG,KAAK,EAAG8K,EAAI9K,EAAI,MACxB,KAAK,EAAc,OAAXxB,EAAEwM,QAAgB,CAAE7R,MAAO6G,EAAG,GAAI7F,MAAM,GAChD,KAAK,EAAGqE,EAAEwM,QAAS7M,EAAI6B,EAAG,GAAIA,EAAK,CAAC,GAAI,SACxC,KAAK,EAAGA,EAAKxB,EAAE2M,IAAIE,MAAO7M,EAAE0M,KAAKG,MAAO,SACxC,QACI,MAAkBP,GAAZA,EAAItM,EAAE0M,MAAY1Q,OAAS,GAAKsQ,EAAEA,EAAEtQ,OAAS,KAAkB,IAAVwF,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAExB,EAAI,EAAG,QAAU,CAC3G,GAAc,IAAVwB,EAAG,MAAc8K,GAAM9K,EAAG,GAAK8K,EAAE,IAAM9K,EAAG,GAAK8K,EAAE,IAAM,CAAEtM,EAAEwM,MAAQhL,EAAG,GAAI,KAAO,CACrF,GAAc,IAAVA,EAAG,IAAYxB,EAAEwM,MAAQF,EAAE,GAAI,CAAEtM,EAAEwM,MAAQF,EAAE,GAAIA,EAAI9K,EAAI,KAAO,CACpE,GAAI8K,GAAKtM,EAAEwM,MAAQF,EAAE,GAAI,CAAEtM,EAAEwM,MAAQF,EAAE,GAAItM,EAAE2M,IAAI/Q,KAAK4F,GAAK,KAAO,CAC9D8K,EAAE,IAAItM,EAAE2M,IAAIE,MAChB7M,EAAE0M,KAAKG,MAAO,SAEtBrL,EAAK4K,EAAKnR,KAAKuQ,EAASxL,EAC5B,CAAE,MAAOzE,GAAKiG,EAAK,CAAC,EAAGjG,GAAIoE,EAAI,CAAG,CAAE,QAAU0M,EAAIC,EAAI,CAAG,CACzD,GAAY,EAAR9K,EAAG,GAAQ,MAAMA,EAAG,GAAI,MAAO,CAAE7G,MAAO6G,EAAG,GAAKA,EAAG,QAAK,EAAQ7F,MAAM,EAC9E,CAtBgDqQ,CAAK,CAAC7Q,EAAGT,GAAK,CAAG,CAuBrE,EACIQ,EAAUpB,MAAQA,KAAKoB,QAAW,SAAUjB,EAAGkB,GAC/C,IAAIjB,EAAsB,mBAAXkB,QAAyBnB,EAAEmB,OAAOC,UACjD,IAAKnB,EAAG,OAAOD,EACf,IAAmBqB,EAAYC,EAA3BC,EAAItB,EAAEe,KAAKhB,GAAOwB,EAAK,GAC3B,IACI,WAAc,IAANN,GAAgBA,KAAM,MAAQG,EAAIE,EAAEE,QAAQC,MAAMF,EAAGG,KAAKN,EAAEX,MACxE,CACA,MAAOkB,GAASN,EAAI,CAAEM,MAAOA,EAAS,CACtC,QACI,IACQP,IAAMA,EAAEK,OAASzB,EAAIsB,EAAU,SAAItB,EAAEe,KAAKO,EAClD,CACA,QAAU,GAAID,EAAG,MAAMA,EAAEM,KAAO,CACpC,CACA,OAAOJ,CACX,EACI4M,EAAYvO,MAAQA,KAAKuO,UAAa,WACtC,IAAK,IAAI5M,EAAK,GAAID,EAAI,EAAGA,EAAI8M,UAAUtM,OAAQR,IAAKC,EAAKA,EAAG8M,OAAOrN,EAAOoN,UAAU9M,KACpF,OAAOC,CACX,EACIqR,EAAmBhT,MAAQA,KAAKgT,iBAAoB,SAAUjS,GAC9D,OAAQA,GAAOA,EAAIC,WAAcD,EAAM,CAAE,QAAWA,EACxD,EACAd,OAAOO,eAAe4B,EAAS,aAAc,CAAEvB,OAAO,IACtDuB,EAAQ6Q,cAAgB7Q,EAAQ8Q,uBAAyB9Q,EAAQ+Q,iBAAmB/Q,EAAQgR,aAAehR,EAAQiR,OAASjR,EAAQkR,UAAYlR,EAAQkM,UAAO,EAC/J,IAAIpF,EAAOpI,EAAa,EAAQ,OAC5B2E,EAAS3E,EAAa,EAAQ,MAC9ByS,EAAYzS,EAAa,EAAQ,OACjCqL,EAAOrL,EAAa,EAAQ,OAC5BkC,EAAQlC,EAAa,EAAQ,OAC7B0S,EAA2BR,EAAgB,EAAQ,OACnDS,EAAqB,KACrBC,EAAmB,KACnBpF,EAAQ,WACR,SAASA,EAAKqF,GACV,IAAItO,EAAQrF,UACG,IAAX2T,IAAqBA,EAAS,CAAC,GACnC3T,KAAK4T,aAAe,EACpB5T,KAAK6T,kBAAoB,EACzB7T,KAAK6L,QAAU,GACf7L,KAAK8T,YAAc,EACnB9T,KAAK+T,QAAU,EACf/T,KAAKgL,WAAa,GAClBhL,KAAKgU,mBAAqB,EAC1BhU,KAAKyK,OAASlD,KAAKkD,OACnBzK,KAAKiU,kBAAoB,EACzBjU,KAAKkU,cAAgB,EACrBlU,KAAKmU,OAAS,EACdnU,KAAKoU,mBAAqB,EAC1BpU,KAAKqU,aAAe,cACpBrU,KAAKsU,aAAe,GACpBtU,KAAKuU,iBAAmBvU,KAAKgL,WAC7BhL,KAAKoM,WAAakH,EAClBtT,KAAKwU,eAAgB,EACrBxU,KAAKqR,SAAW,GAChBrR,KAAKyU,UAAY,GACjBzU,KAAK0U,kBAAoB,IAAIC,EAC7B,IAAIC,EAAW,SAAU/Q,QACDtD,IAAhBoT,EAAO9P,KACPwB,EAAMxB,GAAO8P,EAAO9P,GAC5B,EACA+Q,EAAS,cACTA,EAAS,gBACTA,EAAS,qBACTA,EAAS,WACTA,EAAS,eACTA,EAAS,WACTA,EAAS,cACTA,EAAS,sBACTA,EAAS,UACTA,EAAS,qBACTA,EAAS,iBACTA,EAAS,UACTA,EAAS,qBACb,CAmfA,OAlfAtG,EAAKtK,UAAU6Q,IAAM,SAAUC,GAG3B,OAFA9U,KAAK+U,cAAcD,GACnB9U,KAAKgV,iBACEhV,KAAKyU,SAChB,EACAnG,EAAKtK,UAAUiR,SAAW,SAAUH,EAAGI,GAEnC,YADiB,IAAbA,IAAuBA,EAAW,WAAc,OAAO,CAAM,GAC1DzD,EAAUzR,UAAM,OAAQ,GAAQ,WACnC,OAAOqS,EAAYrS,MAAM,SAAUF,GAC/B,OAAQA,EAAG4S,OACP,KAAK,EAED,OADA1S,KAAK+U,cAAcD,GACZ,CAAC,EAAG9U,KAAKmV,oBAAoBD,IACxC,KAAK,EAED,OADApV,EAAG6S,OACI,CAAC,EAAG3S,KAAKyU,WAE5B,GACJ,GACJ,EACAnG,EAAKtK,UAAUoR,wBAA0B,SAAUC,EAAG1B,QACnC,IAAXA,IAAqBA,EAAS,CAAC,GACnC3T,KAAKqV,EAAIA,EACTrV,KAAKqU,aAAeV,EAAOU,cAAgBrU,KAAKqU,aAChDrU,KAAKsU,aAAeX,EAAOW,cAAgBtU,KAAKsU,aAChDtU,KAAKuU,iBAAmBZ,EAAOY,kBAAoBvU,KAAKuU,gBAC5D,EACAjG,EAAKtK,UAAUsR,kBAAoB,SAAUC,EAAYC,GACrDxV,KAAKuV,WAAaA,EAClBvV,KAAKwV,aAAeA,CACxB,EACAlH,EAAKtK,UAAU+Q,cAAgB,SAAUD,GACrC,GAAIA,EAAE5S,QAAUlC,KAAKgL,WACjB,MAAM,IAAIvH,MAAM,2BAA6BqR,EAAE5S,OAAS,2BAA6BlC,KAAKgL,WAAa,wDAE3G,GAAIhL,KAAK8U,IAAMA,GAAK9U,KAAKwU,cACrB,OAAOxU,KAAKyV,aAGhB,GADAzV,KAAK8U,EAAIA,GACJ9U,KAAKuV,aAAevV,KAAKwV,aAAc,CACxC,IAAIE,EAAa1V,KAAK2V,iBAAiBb,GACvC9U,KAAKuV,WAAaG,EAAWH,WAC7BvV,KAAKwV,aAAeE,EAAWF,YACnC,CACAxV,KAAKsN,MAAQtN,KAAK4V,mBAAmBd,EAAG9U,KAAKgL,WAAYhL,KAAKkU,eAC9DlU,KAAK6V,gBACL7V,KAAK8V,YAAc9V,KAAK+V,gBAAgBjB,GACxC9U,KAAKgW,sCACL,IAAIlW,EAAKE,KAAKiW,mCAAoCC,EAAOpW,EAAGoW,KAAMC,EAAOrW,EAAGqW,KAAMC,EAAkBtW,EAAGsW,gBAOvG,OANApW,KAAK0U,kBAAkBwB,KAAOA,EAC9BlW,KAAK0U,kBAAkByB,KAAOA,EAC9BnW,KAAK0U,kBAAkB0B,gBAAkBA,EACzCpW,KAAKqW,yBACLrW,KAAKsW,6BACLtW,KAAKwU,eAAgB,EACdxU,KAAKyV,YAChB,EACAnH,EAAKtK,UAAU6R,cAAgB,WAC3B,IAAI/V,EAAKyT,EAAUtH,oBAAoBjM,KAAKoM,YAAae,EAAerN,EAAGqN,aAAcH,EAAiBlN,EAAGkN,eAC7GhN,KAAKmN,aAAeA,EACpBnN,KAAKgN,eAAiBA,EACtBhN,KAAKuW,OAAShD,EAAUvH,wBAAwBhM,KAAKoM,WACzD,EACAkC,EAAKtK,UAAU+R,gBAAkB,SAAUjB,GAKvC,IAJA,IAAIS,EAAavV,KAAKuV,WAClBC,EAAexV,KAAKwV,aACpBpS,EAAO,CAAC0R,EAAE5S,OAAQ4S,EAAE5S,QACpB4T,EAAc,IAAIrQ,EAAO1C,aAAa,GAAI,GAAI,GAAIK,GAC7C1B,EAAI,EAAGA,EAAI6T,EAAWrT,OAAQR,IAGnC,IAFA,IAAI8U,EAAMjB,EAAW7T,GACjB+U,EAAYjB,EAAa9T,GACpBiJ,EAAI,EAAGA,EAAI6L,EAAItU,OAAQyI,IAAK,CACjC,IAAI+L,EAAWF,EAAI7L,GACfgM,EAAWF,EAAU9L,GACrBgM,EAAW,GACXb,EAAY/R,IAAIrC,EAAGgV,EAAUC,EAErC,CAEJ,IAAI7T,EAAY2C,EAAO3C,UAAUgT,GACjC,OAAOrQ,EAAOhD,QAAQqT,EAAahT,EACvC,EACAwL,EAAKtK,UAAU4S,UAAY,SAAUC,GACjC,IAAIxR,EAAQrF,KACR8W,EAAU9W,KAAK8U,EACnB,QAAgBvU,IAAZuW,GAA4C,IAAnBA,EAAQ5U,OACjC,MAAM,IAAIuB,MAAM,yBAEpB,IAAIuH,EAAazD,KAAK+B,MAAMtJ,KAAKgL,WAAahL,KAAKoU,oBACnDpJ,EAAazD,KAAKwP,IAAID,EAAQ5U,OAAQ8I,GACtC,IAAIgM,EAAOzD,EAAUxH,iBAAiB/L,KAAKqR,SAAUyF,EAASD,EAAa7L,EAAYhL,KAAKgN,eAAgBhN,KAAKmN,aAAcnN,KAAKyK,QAChIxJ,EAASjB,KAAKuW,OAAOO,EAAS9W,KAAK8V,YAAakB,EAAMH,GACtD/W,EAAKoJ,EAAKV,WAAWvH,GAASmH,EAAUtI,EAAGsI,QAASqO,EAAY3W,EAAGyJ,QACvEnB,EAAUA,EAAQlD,KAAI,SAAUU,GAAK,OAAOA,EAAE+H,MAAM,EAAGtI,EAAM2F,WAAa,IAC1EyL,EAAYA,EAAUvR,KAAI,SAAUU,GAAK,OAAOA,EAAE+H,MAAM,EAAGtI,EAAM2F,WAAa,IAC9E,IAAIiM,EAA4B1P,KAAKF,IAAI,EAAGrH,KAAK6T,kBAAoB,GACjE/O,EAAK9E,KAAKkX,kBAAkBT,EAAWzW,KAAKgL,WAAYiM,GAA4BE,EAASrS,EAAGqS,OAAQC,EAAOtS,EAAGsS,KAClHnQ,EAAKjH,KAAKqX,2BAA2BjP,EAASqO,EAAWU,EAAQC,GAAOnU,EAAOgE,EAAGhE,KAAMC,EAAO+D,EAAG/D,KAAMiC,EAAO8B,EAAG9B,KAClHO,EAAO,CAACmR,EAAY3U,OAAQ4U,EAAQ5U,QACpCoL,EAAQ,IAAI7H,EAAO1C,aAAaE,EAAMC,EAAMiC,EAAMO,GAClD4R,EAAS7R,EAAOnD,UAAUgL,EAAO,MACjCiK,EAAY9R,EAAOpD,OAAOiV,GAC1BxO,EAAU+N,EAAY3U,OAGtBuS,EAAYxB,EAFDjQ,EAAMwU,UAAUD,EAAUnP,QAASU,EAAS9I,KAAKgL,YACjDhI,EAAMwU,UAAUD,EAAUpU,OAAQ2F,EAAS9I,KAAKgL,YACbhL,KAAKyU,WACnDV,EAAU/T,KAAK+T,QACb/T,KAAK+T,QAAU,EACfzG,EAAM/J,OAAS,IACX,IACA,GACNkU,EAAWnK,EACVtI,YACA0S,QAAO,SAAUrQ,EAAKsQ,GAAO,OAAQA,EAAMtQ,EAAMsQ,EAAMtQ,CAAM,GAAG,GACrEiG,EAAQA,EAAMpI,KAAI,SAAUrE,GAAS,OAAQA,EAAQ4W,EAAW1D,EAAU,EAAIlT,CAAQ,IACtFyM,EAAQ7H,EAAOlD,eAAe+K,GAC9B,IAAI8I,EAAkBpW,KAAK4X,oBAAoBtK,EAAMtI,YAAa+O,GAC9DmC,EAAO5I,EAAM3I,UACbwR,EAAO7I,EAAMvI,UAYjB,OAXA/E,KAAK6X,kCAAkC,CACnCC,cAAerD,EACfsD,cAAe/X,KAAKyU,UACpByB,KAAMA,EACNC,KAAMA,EACN6B,aAAc,EACdjE,QAASA,EACThJ,UAAWuC,EAAM5I,UAAU,GAC3B0R,gBAAiBA,IAErBpW,KAAKsW,6BACEtW,KAAKgV,gBAChB,EACA1G,EAAKtK,UAAUgS,oCAAsC,WACjD,IAAeX,EAANrV,KAAaqV,EAAGP,EAAhB9U,KAAuB8U,EAChC,GAAIO,EAAG,CACH,GAAIA,EAAEnT,SAAW4S,EAAE5S,OACf,MAAM,IAAIuB,MAAM,mCAEpB,GAA0B,gBAAtBzD,KAAKqU,aAAgC,CACrC,IACI4D,EADKjY,KAAKsU,aAAe,EACH,GAAO,EAAMtU,KAAKsU,cAAzB,IAA0C,KAC7DtU,KAAKsN,MAAQtN,KAAKkY,qCAAqClY,KAAKsN,MAAO+H,EAAG4C,EAC1E,CACJ,CACJ,EACA3J,EAAKtK,UAAUkO,KAAO,WAClB,IAAI8F,EAAehY,KAAK0U,kBAAkBsD,aAI1C,OAHIA,EAAehY,KAAKyV,cACpBzV,KAAKmY,mBAAmBH,GAErBhY,KAAK0U,kBAAkBsD,YAClC,EACA1J,EAAKtK,UAAUoU,aAAe,WAC1B,OAAOpY,KAAKyU,SAChB,EACAnG,EAAKtK,UAAU2R,iBAAmB,SAAUb,GACxC,IAGsBzT,EAHP+K,EAANpM,KAAsBoM,WAAYpB,EAAlChL,KAAkDgL,WAEvDqN,EAAkB9E,EAAUrH,cAAcE,EAAYpM,KAAKyK,QAI3DsG,EAAS,EAAIxJ,KAAK+B,MAFL,KADKjI,EAGYkG,KAAKC,IAAIsN,EAAE5S,OAAQ,IAAO,IAFrC,EAAIqF,KAAK+Q,MAAMjX,IAGlCkL,EAAShF,KAAKF,IAAI,EAAGE,KAAK+B,MAAM/B,KAAK+Q,MAN9B,SAAUjX,GAAK,OAAOkG,KAAKgR,IAAIlX,GAAKkG,KAAKgR,IAAI,EAAI,CAMbC,CAAK1D,EAAE5S,WACtDlC,KAAKqR,SAAWlF,EAAKwC,WAAWmG,EAAG9J,EAAY+F,EAAQ/Q,KAAKyK,QAC5D,IACI3F,EAAKuT,EAAgBvD,EADT3I,EAAKuC,cAAc1O,KAAKqR,UACDrG,EAAYuB,GACnD,MAAO,CAAEgJ,WAD6DzQ,EAAGsD,QAC3CoN,aAD8D1Q,EAAGyE,QAEnG,EACA+E,EAAKtK,UAAU4R,mBAAqB,SAAUd,EAAG9J,EAAYkJ,QACnC,IAAlBA,IAA4BA,EAAgB,GAChD,IAAIpU,EAAKE,KAAM8E,EAAKhF,EAAGyV,WAAYA,OAAoB,IAAPzQ,EAAgB,GAAKA,EAAImC,EAAKnH,EAAG0V,aAAcA,OAAsB,IAAPvO,EAAgB,GAAKA,EAAI4M,EAAoB/T,EAAG+T,kBAC1J4E,EAAKzY,KAAKkX,kBAAkB1B,EAAcxK,EAAY6I,GAAoBsD,EAASsB,EAAGtB,OAAQC,EAAOqB,EAAGrB,KACxGsB,EAAK1Y,KAAKqX,2BAA2B9B,EAAYC,EAAc2B,EAAQC,GAAOnU,EAAOyV,EAAGzV,KAAMC,EAAOwV,EAAGxV,KAAMiC,EAAOuT,EAAGvT,KACxHO,EAAO,CAACoP,EAAE5S,OAAQ4S,EAAE5S,QACpByW,EAAe,IAAIlT,EAAO1C,aAAaE,EAAMC,EAAMiC,EAAMO,GACzD5C,EAAY2C,EAAO3C,UAAU6V,GAC7BC,EAAanT,EAAO7C,iBAAiB+V,EAAc7V,GACnD0B,EAAIiB,EAAO/C,SAAS+C,EAAO9C,IAAIgW,EAAc7V,GAAY8V,GACzDnU,EAAIgB,EAAOjD,eAAegC,EAAG0P,GAC7BvH,EAAIlH,EAAOjD,eAAeoW,EAAY,EAAM1E,GAEhD,OADazO,EAAO9C,IAAI8B,EAAGkI,EAE/B,EACA2B,EAAKtK,UAAUkU,qCAAuC,SAAUW,EAAeC,EAAQb,EAASc,QACxE,IAAhBA,IAA0BA,EAAc,GAC5C,IAAIC,EAAe7F,EAAiB0F,EAAeC,EAAQC,EAAad,GAExE,OAAO/E,EADP8F,EAAevT,EAAOlD,eAAeyW,GAEzC,EACA1K,EAAKtK,UAAUkT,kBAAoB,SAAUT,EAAWpW,EAAGwT,EAAmBoF,EAAOC,QACvD,IAAtBrF,IAAgCA,EAAoB,QAC1C,IAAVoF,IAAoBA,EAAQ,SACd,IAAdC,IAAwBA,EAAY,GAIxC,IAHA,IAAIJ,EAAUvR,KAAKgR,IAAIlY,GAAKkH,KAAKgR,IAAI,GAAMW,EACvCzM,EAAMzJ,EAAMwC,MAAMiR,EAAUvU,QAC5BjB,EAAS+B,EAAMwC,MAAMiR,EAAUvU,QAC1BR,EAAI,EAAGA,EAAI+U,EAAUvU,OAAQR,IAAK,CACvC,IAAIyX,EAAK,EACLC,EAAKjQ,IACLkQ,EAAM,EACNC,EAAe7C,EAAU/U,GACzB6X,EAAeD,EAAajT,QAAO,SAAUgF,GAAK,OAAOA,EAAI,CAAK,IACtE,GAAIkO,EAAarX,QAAU2R,EAAmB,CAC1C,IAAI1N,EAAQoB,KAAK+B,MAAMuK,GACnB2F,EAAgB3F,EAAoB1N,EACpCA,EAAQ,GACRsG,EAAI/K,GAAK6X,EAAapT,EAAQ,GAC1BqT,EAAgB/F,IAChBhH,EAAI/K,IACA8X,GAAiBD,EAAapT,GAASoT,EAAapT,EAAQ,MAIpEsG,EAAI/K,GAAK8X,EAAgBD,EAAa,EAE9C,MACSA,EAAarX,OAAS,IAC3BuK,EAAI/K,GAAKsB,EAAMqE,IAAIkS,IAEvB,IAAK,IAAIlY,EAAI,EAAGA,EAAI4X,EAAO5X,IAAK,CAE5B,IADA,IAAIoY,EAAO,EACF9O,EAAI,EAAGA,EAAI8L,EAAU/U,GAAGQ,OAAQyI,IAAK,CAC1C,IAAIU,EAAIoL,EAAU/U,GAAGiJ,GAAK8B,EAAI/K,GAE1B+X,GADApO,EAAI,EACI9D,KAAKmS,KAAMrO,EAAIgO,GAGf,CAEhB,CACA,GAAI9R,KAAKoS,IAAIF,EAAOX,GAAUrF,EAC1B,MAEAgG,EAAOX,EAEPO,GAAOF,GADPC,EAAKC,IACa,GAGlBF,EAAKE,EACDD,IAAOjQ,IACPkQ,GAAO,EAGPA,GAAOF,EAAKC,GAAM,EAG9B,CAEA,GADAnY,EAAOS,GAAK2X,EACR5M,EAAI/K,GAAK,EAAK,CACd,IAAIkY,EAAmB5W,EAAM6W,KAAKP,GAC9BrY,EAAOS,GAAKgS,EAAmBkG,IAC/B3Y,EAAOS,GAAKgS,EAAmBkG,EAEvC,KACK,CACD,IAAIE,EAAgB9W,EAAM6W,KAAKpD,EAAUvR,IAAIlC,EAAM6W,OAC/C5Y,EAAOS,GAAKgS,EAAmBoG,IAC/B7Y,EAAOS,GAAKgS,EAAmBoG,EAEvC,CACJ,CACA,MAAO,CAAE3C,OAAQlW,EAAQmW,KAAM3K,EACnC,EACA6B,EAAKtK,UAAUqT,2BAA6B,SAAU9B,EAAYC,EAAc2B,EAAQC,GAMpF,IALA,IAAI7M,EAAWgL,EAAWrT,OACtB8I,EAAauK,EAAW,GAAGrT,OAC3Be,EAAOD,EAAMwC,MAAM+E,EAAWS,GAC9B9H,EAAOF,EAAMwC,MAAM+E,EAAWS,GAC9B7F,EAAOnC,EAAMwC,MAAM+E,EAAWS,GACzBtJ,EAAI,EAAGA,EAAI6I,EAAU7I,IAC1B,IAAK,IAAIiJ,EAAI,EAAGA,EAAIK,EAAYL,IAAK,CACjC,IAAIgN,EAAM,GACgB,IAAtBpC,EAAW7T,GAAGiJ,KAIdgN,EADApC,EAAW7T,GAAGiJ,KAAOjJ,EACf,EAED8T,EAAa9T,GAAGiJ,GAAKyM,EAAK1V,IAAM,EAC/B,EAGA6F,KAAKmS,MAAOlE,EAAa9T,GAAGiJ,GAAKyM,EAAK1V,IAAMyV,EAAOzV,IAE7DuB,EAAKvB,EAAIsJ,EAAaL,GAAKjJ,EAC3BwB,EAAKxB,EAAIsJ,EAAaL,GAAK4K,EAAW7T,GAAGiJ,GACzCxF,EAAKzD,EAAIsJ,EAAaL,GAAKgN,EAC/B,CAEJ,MAAO,CAAE1U,KAAMA,EAAMC,KAAMA,EAAMiC,KAAMA,EAC3C,EACAmJ,EAAKtK,UAAUiS,iCAAmC,WAM9C,IALA,IAAI5Q,EAAQrF,KACR+T,EAAU/T,KAAKyV,aACf3B,EAAc9T,KAAK8T,YACnBiG,EAAc/Z,KAAKsN,MAAMtI,YACzByS,EAAW,EACN/V,EAAI,EAAGA,EAAIqY,EAAY7X,OAAQR,IAAK,CACzC,IAAIb,EAAQkZ,EAAYrY,GACpB+V,EAAWsC,EAAYrY,KACvB+V,EAAW5W,EAEnB,CACA,IAAIyM,EAAQtN,KAAKsN,MAAMpI,KAAI,SAAUrE,GACjC,OAAIA,EAAQ4W,EAAW1D,EACZ,EAGAlT,CAEf,IACAb,KAAKyU,UAAYzR,EAAMwC,MAAM8H,EAAM/J,OAAO2B,KAAI,WAC1C,OAAOlC,EAAMwC,MAAMsO,GAAa5O,KAAI,WAChC,OAAqC,GAA9BlC,EAAMsI,QAAQjG,EAAMoF,QAAgB,EAC/C,GACJ,IACA,IAAIlB,EAAU,GACV2M,EAAO,GACPC,EAAO,GACP9R,EAAeiJ,EAAMnJ,SACzB,IAASzC,EAAI,EAAGA,EAAI2C,EAAanC,OAAQR,IAAK,CAC1C,IAAIsY,EAAQ3V,EAAa3C,GACrBsY,EAAMnZ,QACN0I,EAAQzH,KAAKkY,EAAMnZ,OACnBsV,EAAKrU,KAAKkY,EAAMtW,KAChBwS,EAAKpU,KAAKkY,EAAMrW,KAExB,CAEA,MAAO,CAAEuS,KAAMA,EAAMC,KAAMA,EAAMC,gBADXpW,KAAK4X,oBAAoBrO,EAASwK,GAE5D,EACAzF,EAAKtK,UAAU4T,oBAAsB,SAAUrO,EAASwK,GACpD,IAAI9S,EAAS+B,EAAMiG,OAAOM,EAAQrH,QAAS,GACvCmF,EAAMrE,EAAMqE,IAAIkC,GAChBgB,EAAWhB,EAAQrE,KAAI,SAAU+U,GAAK,OAAQA,EAAI5S,EAAO0M,CAAS,IAKtE,OAJAxJ,EAASjG,SAAQ,SAAUjD,EAAGK,GACtBL,EAAI,IACJJ,EAAOS,GAAKqS,EAAUxJ,EAAS7I,GACvC,IACOT,CACX,EACAqN,EAAKtK,UAAU6T,kCAAoC,SAAUqC,GACzDja,OAAOka,OAAOna,KAAK0U,kBAAmBwF,EAC1C,EACA5L,EAAKtK,UAAUsS,2BAA6B,WACxC,IAAIxW,EAAKE,KAAMiU,EAAoBnU,EAAGmU,kBAAmBL,EAAe9T,EAAG8T,aAAcI,EAAqBlU,EAAGkU,mBAC7GlP,EAAK9E,KAAK0U,kBAAmB0B,EAAkBtR,EAAGsR,gBAAiB0B,EAAgBhT,EAAGgT,cAAeC,EAAgBjT,EAAGiT,cACxH5I,EAAM2I,EAAc,GAAG5V,OACvBkY,EAAYtC,EAAc5V,SAAW6V,EAAc7V,OACnDmY,EAA0BjE,EAAgBlR,KAAI,SAAUzD,GAAK,OAAOA,EAAIuS,CAAoB,IAC5FsG,EAA4B/L,EAAS8L,GACrCE,EAAoBhM,EAAS6H,GACjCpW,KAAK6X,kCAAkC,CACnC0C,kBAAmBA,EACnBD,0BAA2BA,EAC3BD,wBAAyBA,EACzBD,UAAWA,EACXI,aAAc5G,EACd6G,MAAO7G,EACP8G,MAAOzG,EACP9E,IAAKA,GAEb,EACAb,EAAKtK,UAAUqS,uBAAyB,WACpC,IAAIyB,EAAgB9X,KAAKyU,UACrBsD,EAAgB/X,KAAKyU,UACrB3U,EAAKE,KAAK0U,kBAAmBwB,EAAOpW,EAAGoW,KAAMC,EAAOrW,EAAGqW,KAAMC,EAAkBtW,EAAGsW,gBAClFrC,EAAU/T,KAAKyV,aACf1K,EAAY/K,KAAKsN,MAAM9J,MACvBsB,EAAKsO,EAAapT,KAAKmU,OAAQnU,KAAK6L,SAAUrH,EAAIM,EAAGN,EAAGC,EAAIK,EAAGL,EACnEzE,KAAK6X,kCAAkC,CACnCC,cAAeA,EACfC,cAAeA,EACf7B,KAAMA,EACNC,KAAMA,EACNC,gBAAiBA,EACjB5R,EAAGA,EACHC,EAAGA,EACHsP,QAASA,EACThJ,UAAWA,GAEnB,EACAuD,EAAKtK,UAAUmU,mBAAqB,SAAU9W,GAI1C,IAHA,IAAIqT,EAAoB1U,KAAK0U,kBACzBwB,EAAOxB,EAAkBwB,KAAMC,EAAOzB,EAAkByB,KAAM2B,EAAgBpD,EAAkBoD,cAAeC,EAAgBrD,EAAkBqD,cAAe3B,EAAkB1B,EAAkB0B,gBAAiBmE,EAAoB7F,EAAkB6F,kBAAmBD,EAA4B5F,EAAkB4F,0BAA2BD,EAA0B3F,EAAkB2F,wBAAyBD,EAAY1F,EAAkB0F,UAAWI,EAAe9F,EAAkB8F,aAAcC,EAAQ/F,EAAkB+F,MAAOC,EAAQhG,EAAkBgG,MAAOlW,EAAIkQ,EAAkBlQ,EAAGC,EAAIiQ,EAAkBjQ,EAAG0K,EAAMuF,EAAkBvF,IAAK4E,EAAUW,EAAkBX,QAAShJ,EAAY2J,EAAkB3J,UAEnsBrJ,EAAI,EAAGA,EAAI0U,EAAgBlU,OAAQR,IACxC,KAAI6Y,EAAkB7Y,GAAKL,GAA3B,CAGA,IAAIsJ,EAAIuL,EAAKxU,GACTrB,EAAI8V,EAAKzU,GACTiZ,EAAU7C,EAAcnN,GACxBiQ,EAAQ7C,EAAc1X,GACtBwa,EAAcC,EAAMH,EAASC,GAC7BG,EAAY,EACZF,EAAc,IACdE,GAAa,EAAMvW,EAAIC,EAAI8C,KAAKC,IAAIqT,EAAapW,EAAI,GACrDsW,GAAavW,EAAI+C,KAAKC,IAAIqT,EAAapW,GAAK,GAEhD,IAAK,IAAI4G,EAAI,EAAGA,EAAI8D,EAAK9D,IAAK,CAC1B,IAAI2P,EAAQC,EAAKF,GAAaJ,EAAQtP,GAAKuP,EAAMvP,IAhBzC,GAiBRsP,EAAQtP,IAAM2P,EAAQP,EAClBL,IACAQ,EAAMvP,KAAO2P,EAAQP,EAE7B,CACAF,EAAkB7Y,IAAM0U,EAAgB1U,GAExC,IADA,IAAIwZ,EAAc3T,KAAK+B,OAAOjI,EAAIiZ,EAA0B5Y,IAAM2Y,EAAwB3Y,IACjFkL,EAAI,EAAGA,EAAIsO,EAAatO,IAAK,CAClC,IAAIuO,EAAMnY,EAAM4H,WAAWG,EAAW/K,KAAKyK,QACvC2Q,EAAUrD,EAAcoD,GACxBE,EAAgBP,EAAMH,EAASS,GAC/BE,EAAc,EAClB,GAAID,EAAgB,EAChBC,EAAc,EAAMZ,EAAQjW,EAC5B6W,IACK,KAAQD,IAAkB7W,EAAI+C,KAAKC,IAAI6T,EAAe5W,GAAK,QAE/D,GAAIkG,IAAMwQ,EACX,SAEJ,IAAS9P,EAAI,EAAGA,EAAI8D,EAAK9D,IACjB2P,EAAQ,EACRM,EAAc,IACdN,EAAQC,EAAKK,GAAeX,EAAQtP,GAAK+P,EAAQ/P,IAxCjD,IA0CJsP,EAAQtP,IAAM2P,EAAQP,CAE9B,CACAH,EAA0B5Y,IAAMwZ,EAAcb,EAAwB3Y,EAzCtE,CA6CJ,OAFAgT,EAAkB+F,MAAQD,GAAgB,EAAMnZ,EAAI0S,GACpDW,EAAkBsD,cAAgB,EAC3BF,CACX,EACAxJ,EAAKtK,UAAUmR,oBAAsB,SAAUoG,GAC3C,IAAIlW,EAAQrF,KAEZ,YADsB,IAAlBub,IAA4BA,EAAgB,WAAc,OAAO,CAAM,GACpE,IAAIzJ,SAAQ,SAAUC,EAASC,GAClC,IAAIE,EAAO,WAAc,OAAOT,EAAUpM,OAAO,OAAQ,GAAQ,WAC7D,IAAIvF,EAAIiU,EAASiE,EAAcwD,EAAgBC,EAAYC,EAC3D,OAAOrJ,EAAYrS,MAAM,SAAU8E,GAC/B,IAMI,GALAhF,EAAKE,KAAK0U,kBAAmBX,EAAUjU,EAAGiU,QAASiE,EAAelY,EAAGkY,aACrEhY,KAAKyU,UAAYzU,KAAKmY,mBAAmBH,GACzCwD,EAAiBxb,KAAK0U,kBAAkBsD,aACxCyD,GAA+C,IAAlCF,EAAcC,GAC3BE,EAAaF,IAAmBzH,EAC3B0H,GAAeC,EAIhB,MAAO,CAAC,EAAG3J,EAAQ2J,IAHnBC,YAAW,WAAc,OAAOzJ,GAAQ,GAAG,EAKnD,CACA,MAAO0J,GACH5J,EAAO4J,EACX,CACA,MAAO,CAAC,EACZ,GACJ,GAAI,EACJD,YAAW,WAAc,OAAOzJ,GAAQ,GAAG,EAC/C,GACJ,EACA5D,EAAKtK,UAAUgR,eAAiB,SAAUuG,QAChB,IAAlBA,IAA4BA,EAAgB,WAAc,OAAO,CAAM,GAG3E,IAFA,IAAIG,GAAa,EACbjH,EAAY,IACRiH,GAAY,CAChB,IAAI5b,EAAKE,KAAK0U,kBAAmBX,EAAUjU,EAAGiU,QAASiE,EAAelY,EAAGkY,aACzEvD,EAAYzU,KAAKmY,mBAAmBH,GACpC,IAAIwD,EAAiBxb,KAAK0U,kBAAkBsD,aACxCyD,GAA+C,IAAlCF,EAAcC,GAC/BE,EAAaF,IAAmBzH,GAAW0H,CAC/C,CACA,OAAOhH,CACX,EACAnG,EAAKtK,UAAUyR,WAAa,WACxB,IAAInI,EAAQtN,KAAKsN,MACjB,GAAItN,KAAK+T,QAAU,EACf,OAAO/T,KAAK+T,QAEhB,IAAI7R,EAASoL,EAAM/J,MACnB,OAAIrB,GAAU,KACH,IAEFA,GAAU,IACR,IAEFA,GAAU,KACR,IAGA,GAEf,EACOoM,CACX,CA7hBW,GA+hBX,SAASgF,EAAU1N,EAAGC,GAElB,IADA,IAAI5E,EAAS,EACJS,EAAI,EAAGA,EAAIkE,EAAE1D,OAAQR,IAC1BT,GAAUsG,KAAKC,IAAK5B,EAAElE,GAAKmE,EAAEnE,GAAK,GAEtC,OAAO6F,KAAKE,KAAKxG,EACrB,CAPAmB,EAAQkM,KAAOA,EAQflM,EAAQkR,UAAYA,EAoBpBlR,EAAQiR,OAnBR,SAAgBzN,EAAGC,GAIf,IAHA,IAAI5E,EAAS,EACT4a,EAAQ,EACRC,EAAQ,EACHpa,EAAI,EAAGA,EAAIkE,EAAE1D,OAAQR,IAC1BT,GAAU2E,EAAElE,GAAKmE,EAAEnE,GACnBma,GAAStU,KAAKC,IAAI5B,EAAElE,GAAI,GACxBoa,GAASvU,KAAKC,IAAI3B,EAAEnE,GAAI,GAE5B,OAAc,IAAVma,GAAyB,IAAVC,EACR,EAEQ,IAAVD,GAAyB,IAAVC,EACb,EAGA,EAAM7a,EAASsG,KAAKE,KAAKoU,EAAQC,EAEhD,EAEA,IAAInH,EACA,WACI3U,KAAKgY,aAAe,EACpBhY,KAAK8X,cAAgB,GACrB9X,KAAK+X,cAAgB,GACrB/X,KAAKkW,KAAO,GACZlW,KAAKmW,KAAO,GACZnW,KAAKoW,gBAAkB,GACvBpW,KAAKua,kBAAoB,GACzBva,KAAKsa,0BAA4B,GACjCta,KAAKqa,wBAA0B,GAC/Bra,KAAKoa,WAAY,EACjBpa,KAAKwa,aAAe,EACpBxa,KAAKya,MAAQ,EACbza,KAAK0a,MAAQ,EACb1a,KAAKwE,EAAI,mBACTxE,KAAKyE,EAAI,kBACTzE,KAAKmP,IAAM,EACXnP,KAAK+T,QAAU,IACf/T,KAAK+K,UAAY,CACrB,EAGJ,SAASkQ,EAAKrV,EAAGmW,GACb,OAAInW,EAAImW,EACGA,EACFnW,GAAKmW,GACFA,EAEDnW,CACf,CACA,SAASkV,EAAMlV,EAAGC,GAEd,IADA,IAAI5E,EAAS,EACJS,EAAI,EAAGA,EAAIkE,EAAE1D,OAAQR,IAC1BT,GAAUsG,KAAKC,IAAI5B,EAAElE,GAAKmE,EAAEnE,GAAI,GAEpC,OAAOT,CACX,CACA,SAASmS,EAAae,EAAQtI,GAC1B,IAMImQ,EAAKhZ,EACJiZ,OAAO,EAAY,EAAT9H,EAAY,KACtBjP,KAAI,SAAUyS,GAAO,OAAQA,EAAM9L,EAAU,EAAM8L,CAAM,IAC1DuE,EAAKlZ,EAAMwC,MAAMwW,EAAG9Z,QAAQgD,KAAI,SAAUyS,EAAKxR,GAE/C,OADU6V,EAAG7V,IAAU0F,EACVtE,KAAKmS,MAAMsC,EAAG7V,GAAS0F,GAAWsI,GAAUwD,CAC7D,IAEItL,EAAO,CAAEzG,EAAGoW,EAAInW,EAAGqW,GAQnBC,EAAkB3I,EAAyB4I,QAAQ/P,GAtB3C,SAAUvM,GAClB,IAAIgF,EAAK1D,EAAOtB,EAAI,GAAI0E,EAAIM,EAAG,GAAIL,EAAIK,EAAG,GAC1C,OAAO,SAAUc,GACb,OAAO,GAAO,EAAMpB,EAAI+C,KAAKC,IAAI5B,EAAI,EAAInB,GAC7C,CACJ,GAUc,CACV4X,QAAS,IACTC,cAJgB,CAAC,GAAK,IAKtBC,mBAAoB,GACpBC,cAAe,IACfC,eAAgB,MAEyDN,gBACzErc,EAAKsB,EAAO+a,EAAiB,GACjC,MAAO,CAAE3X,EADgC1E,EAAG,GAC7B2E,EADqC3E,EAAG,GAE3D,CAEA,SAASqT,EAAiB7F,EAAOwL,EAAQC,EAAad,GAGlD,YAFoB,IAAhBc,IAA0BA,EAAc,QAC5B,IAAZd,IAAsBA,EAAU,GAC7B3K,EAAMpI,KAAI,SAAUrE,EAAO6C,EAAKC,GACnC,OAAqB,IAAjBmV,EAAOpV,KAAgC,IAAjBoV,EAAOnV,GACtB9C,EAAQ0G,KAAKmS,KAAKX,GAEpBD,EAAOpV,KAASoV,EAAOnV,GACrB9C,EAAQ0G,KAAKmS,KAAKzB,GAGlBpX,CAEf,GACJ,CAEA,SAASqS,EAAuB2F,GAC5BA,EAAgBpT,EAAOnD,UAAUuW,EAAe,OAChD,IAAI/V,EAAY2C,EAAO3C,UAAU+V,GAC7BD,EAAanT,EAAO7C,iBAAiBE,EAAW+V,GAEpD,OADAA,EAAgBpT,EAAO9C,IAAIkW,EAAepT,EAAO/C,SAASI,EAAW8V,IAC9DnT,EAAOlD,eAAesW,EACjC,CAEA,SAAS5F,EAAc7K,EAASmB,EAASkL,GAIrC,IAHA,IAAIxT,EAAS+B,EACRwC,MAAM4C,EAAQlG,QACdgD,KAAI,SAAUwX,GAAK,OAAO1Z,EAAMwC,MAAMiP,EAAU,GAAGvS,OAAS,IACxDR,EAAI,EAAGA,EAAI0G,EAAQlG,OAAQR,IAChC,IAAK,IAAIiJ,EAAI,EAAGA,EAAIvC,EAAQ,GAAGlG,OAAQyI,IACnC,IAAK,IAAIU,EAAI,EAAGA,EAAIoJ,EAAU,GAAGvS,OAAQmJ,IAAK,CAC1C,IAAI7G,EAAI4D,EAAQ1G,GAAGiJ,GACnB1J,EAAOS,GAAG2J,IAAM9B,EAAQ7H,GAAGiJ,GAAK8J,EAAUjQ,GAAG6G,EACjD,CAGR,OAAOpK,CACX,CAtCAmB,EAAQgR,aAAeA,EAgBvBhR,EAAQ+Q,iBAAmBA,EAQ3B/Q,EAAQ8Q,uBAAyBA,EAejC9Q,EAAQ6Q,cAAgBA,C,+CC5vBxB,MAAM,EAAWhT,OAAO+D,UAAU2Y,SAEnB,SAASC,EAAWC,GACjC,OAAO,EAAS1b,KAAK0b,GAAQC,SAAS,SACxC,CCIe,SAASC,EACtB1Q,EACA2Q,EACAC,GAEA,IAAIlb,EAAQ,EACZ,MAAMmb,EAAOD,EAAsBD,GAEnC,IAAK,IAAItb,EAAI,EAAGA,EAAI2K,EAAKzG,EAAE1D,OAAQR,IACjCK,GAASwF,KAAKoS,IAAItN,EAAKxG,EAAEnE,GAAKwb,EAAK7Q,EAAKzG,EAAElE,KAG5C,OAAOK,CACT,C,cC6Ce,SAASmQ,EACtB7F,EACAsH,EACA0I,EACAE,EACAU,GAEA,IAAIpc,EAAQwb,EAAUE,EAAqBA,EACvC1Z,EAAW,KAAOsa,IAAIxJ,EAAOzR,OAAQyR,EAAOzR,OAAQrB,GAExD,MAAMqc,EAAOD,EAAsBtJ,GAEnC,IAAIyJ,EAAgB,IAAIC,aAAahR,EAAKzG,EAAE1D,QAC5C,IAAK,IAAIR,EAAI,EAAGA,EAAI2K,EAAKzG,EAAE1D,OAAQR,IACjC0b,EAAc1b,GAAKwb,EAAK7Q,EAAKzG,EAAElE,IAGjC,IAAI4b,EAvEN,SACEjR,EACA+Q,EACAzJ,EACA4I,EACAgB,GAEA,MAAMlc,EAAIsS,EAAOzR,OACX9B,EAAIiM,EAAKzG,EAAE1D,OAEjB,IAAIsb,EAAM,IAAI5Y,MAAMvD,GAEpB,IAAK,IAAIoc,EAAQ,EAAGA,EAAQpc,EAAGoc,IAAS,CACtCD,EAAIC,GAAS,IAAI7Y,MAAMxE,GACvB,IAAIsd,EAAY/J,EAAOhG,QACvB+P,EAAUD,IAAUlB,EACpB,IAAIoB,EAAYJ,EAAcG,GAE9B,IAAK,IAAI5M,EAAQ,EAAGA,EAAQ1Q,EAAG0Q,IAC7B0M,EAAIC,GAAO3M,GAASsM,EAActM,GAAS6M,EAAUtR,EAAKzG,EAAEkL,GAEhE,CACA,OAAO,IAAI,KAAO0M,EACpB,CAgDqBI,CACjBvR,EACA+Q,EACAzJ,EACA4I,EACAU,GAEEY,EA9CN,SAAwBxR,EAAM+Q,GAC5B,MAAMhd,EAAIiM,EAAKzG,EAAE1D,OAEjB,IAAIsb,EAAM,IAAI5Y,MAAMxE,GAEpB,IAAK,IAAI0Q,EAAQ,EAAGA,EAAQ1Q,EAAG0Q,IAC7B0M,EAAI1M,GAAS,CAACzE,EAAKxG,EAAEiL,GAASsM,EAActM,IAG9C,OAAO,IAAI,KAAO0M,EACpB,CAoCmBM,CAAezR,EAAM+Q,GAClCW,GAAgB,QAClBlb,EAASF,IAAI2a,EAAaU,KAAKV,EAAaxa,eAY9C,OARA6Q,GADAA,EAAS,IAAI,KAAO,CAACA,KACLsK,IACdF,EACGC,KAAKV,GACLU,KAAKH,GACLK,IAAI3B,GACJzZ,cAGSqb,WAChB,CCtFe,SAASC,EACtB/R,EACA4Q,EACAoB,EAAU,CAAC,GAEX,IAAI,cACF7B,EAAgB,IAAG,mBACnBD,EAAqB,GAAK,QAC1BF,EAAU,EAAC,eACXI,EAAiB,IAAK,UACtB6B,EAAS,UACTC,EAAS,cACTjC,GACE+B,EAEJ,GAAIhC,GAAW,EACb,MAAM,IAAI5Y,MAAM,gDACX,IAAK4I,EAAKzG,IAAMyG,EAAKxG,EAC1B,MAAM,IAAIpC,MAAM,iDACX,IACJ,EAAQ4I,EAAKzG,IACdyG,EAAKzG,EAAE1D,OAAS,IACf,EAAQmK,EAAKxG,IACdwG,EAAKxG,EAAE3D,OAAS,EAEhB,MAAM,IAAIuB,MACR,wEAEG,GAAI4I,EAAKzG,EAAE1D,SAAWmK,EAAKxG,EAAE3D,OAClC,MAAM,IAAIuB,MAAM,uDAGlB,IAAIuZ,EACFV,GAAiB,IAAI1X,MAAMqY,EAAsB/a,QAAQsc,KAAK,GAC5DC,EAASzB,EAAW9a,OAIxB,GAHAqc,EAAYA,GAAa,IAAI3Z,MAAM6Z,GAAQD,KAAKE,OAAOC,kBACvDL,EAAYA,GAAa,IAAI1Z,MAAM6Z,GAAQD,KAAKE,OAAOE,kBAEnDL,EAAUrc,SAAWoc,EAAUpc,OACjC,MAAM,IAAIuB,MAAM,iDAGlB,IAAK,EAAQuZ,GACX,MAAM,IAAIvZ,MAAM,kCAGlB,IAIIob,EAJA9c,EAAQgb,EAAiB1Q,EAAM2Q,EAAYC,GAE3C6B,EAAY/c,GAAS0a,EAGzB,IAAKoC,EAAY,EAAGA,EAAYrC,IAAkBsC,EAAWD,IAAa,CACxE7B,EAAa9K,EACX7F,EACA2Q,EACAX,EACAE,EACAU,GAGF,IAAK,IAAI5c,EAAI,EAAGA,EAAIoe,EAAQpe,IAC1B2c,EAAW3c,GAAKkH,KAAKwP,IACnBxP,KAAKF,IAAIiX,EAAUje,GAAI2c,EAAW3c,IAClCke,EAAUle,IAKd,GADA0B,EAAQgb,EAAiB1Q,EAAM2Q,EAAYC,GACvC8B,MAAMhd,GAAQ,MAClB+c,EAAY/c,GAAS0a,CACvB,CAEA,MAAO,CACLN,gBAAiBa,EACjBgC,eAAgBjd,EAChBkd,WAAYJ,EAEhB,C,qBC/FA,IAAI7c,EAAYhC,MAAQA,KAAKgC,UAAa,SAAS7B,GAC/C,IAAI8B,EAAsB,mBAAXX,QAAyBA,OAAOC,SAAUnB,EAAI6B,GAAK9B,EAAE8B,GAAIP,EAAI,EAC5E,GAAItB,EAAG,OAAOA,EAAEe,KAAKhB,GACrB,GAAIA,GAAyB,iBAAbA,EAAE+B,OAAqB,MAAO,CAC1CN,KAAM,WAEF,OADIzB,GAAKuB,GAAKvB,EAAE+B,SAAQ/B,OAAI,GACrB,CAAEU,MAAOV,GAAKA,EAAEuB,KAAMG,MAAO1B,EACxC,GAEJ,MAAM,IAAIgC,UAAUF,EAAI,0BAA4B,kCACxD,EAGA,SAAS2I,EAAWvJ,EAAGoJ,GACnB,OAAOlD,KAAK+B,MAAMmB,IAAWpJ,EACjC,CAyBA,SAASkE,EAAMlE,GAEX,IADA,IAAIiE,EAAS,GACJ5D,EAAI,EAAGA,EAAIL,EAAGK,IACnB4D,EAAOxD,UAAKvB,GAEhB,OAAO+E,CACX,CAMA,SAAS2D,EAAO5H,EAAGT,GACf,OAAO2E,EAAMlE,GAAG6D,KAAI,WAAc,OAAOtE,CAAG,GAChD,CAEA,SAAS4E,EAAMnE,GACX,OAAO4H,EAAO5H,EAAG,EACrB,CAYA,SAASiG,EAAI4X,GACT,OAAOA,EAAMxH,QAAO,SAAUpQ,EAAKqQ,GAAO,OAAOrQ,EAAMqQ,CAAK,GAChE,CA7DA1X,OAAOO,eAAe4B,EAAS,aAAc,CAAEvB,OAAO,IACtDuB,EAAQoV,UAAYpV,EAAQwG,gBAAkBxG,EAAQ+c,MAAQ/c,EAAQiF,IAAMjF,EAAQyX,KAAOzX,EAAQkF,IAAMlF,EAAQ6Z,OAAS7Z,EAAQgd,KAAOhd,EAAQoD,MAAQpD,EAAQ6G,OAAS7G,EAAQ4O,MAAQ5O,EAAQmD,MAAQnD,EAAQ2E,KAAO3E,EAAQkJ,QAAUlJ,EAAQwI,gBAAa,EAIhQxI,EAAQwI,WAAaA,EAIrBxI,EAAQkJ,QAHR,SAAiBb,GACb,OAAOA,GACX,EAoBArI,EAAQ2E,KAlBR,SAAcsY,GACV,IAAI5Y,EAAK3G,EACLmB,EAAS,EACb,IACI,IAAK,IAAIqe,EAAQtd,EAASqd,GAAME,EAAUD,EAAM1d,QAAS2d,EAAQ1d,KAAM0d,EAAUD,EAAM1d,OAAQ,CAC3F,IAAI4d,EAAOD,EAAQ1e,MACnBI,GAAUsG,KAAKC,IAAIgY,EAAM,EAC7B,CACJ,CACA,MAAOtY,GAAST,EAAM,CAAE1E,MAAOmF,EAAS,CACxC,QACI,IACQqY,IAAYA,EAAQ1d,OAAS/B,EAAKwf,EAAMnY,SAASrH,EAAGqB,KAAKme,EACjE,CACA,QAAU,GAAI7Y,EAAK,MAAMA,EAAI1E,KAAO,CACxC,CACA,OAAOwF,KAAKE,KAAKxG,EACrB,EASAmB,EAAQmD,MAAQA,EAIhBnD,EAAQ4O,MAHR,SAAe3P,GACX,OAAOkE,EAAMlE,GAAG6D,KAAI,SAAUgB,EAAGxE,GAAK,OAAOA,CAAG,GACpD,EAKAU,EAAQ6G,OAASA,EAIjB7G,EAAQoD,MAAQA,EAIhBpD,EAAQgd,KAHR,SAAc/d,GACV,OAAO4H,EAAO5H,EAAG,EACrB,EAOAe,EAAQ6Z,OALR,SAAgBzX,EAAGC,EAAGgb,GAClB,OAAOla,EAAMka,GAAKva,KAAI,SAAUgB,EAAGxE,GAC/B,OAAO8C,EAAI9C,IAAM+C,EAAID,IAAMib,EAAM,GACrC,GACJ,EAKArd,EAAQkF,IAAMA,EAIdlF,EAAQyX,KAHR,SAAcqF,GACV,OAAO5X,EAAI4X,GAASA,EAAMhd,MAC9B,EASAE,EAAQiF,IAPR,SAAa6X,GAET,IADA,IAAI7X,EAAM,EACD3F,EAAI,EAAGA,EAAIwd,EAAMhd,OAAQR,IAC9B2F,EAAM6X,EAAMxd,GAAK2F,EAAM6X,EAAMxd,GAAK2F,EAEtC,OAAOA,CACX,EAWAjF,EAAQ+c,MATR,SAAeD,GAEX,IADA,IAAI7X,EAAM,EACD3F,EAAI,EAAGA,EAAIwd,EAAMhd,OAAQR,IAC9B,IAAK,IAAIiJ,EAAI,EAAGA,EAAIuU,EAAMxd,GAAGQ,OAAQyI,IACjCtD,EAAM6X,EAAMxd,GAAGiJ,GAAKtD,EAAM6X,EAAMxd,GAAGiJ,GAAKtD,EAGhD,OAAOA,CACX,EAuBAjF,EAAQwG,gBArBR,SAAyB2B,EAAUC,EAAUC,GAEzC,IADA,IAAIxJ,EAASuE,EAAM+E,GACV7I,EAAI,EAAGA,EAAI6I,EAAU7I,IAE1B,IADA,IAAIgJ,GAAe,EACZA,GAAc,CAGjB,IAFA,IAAIC,EAAIC,EAAWJ,EAAUC,GACzBI,GAAS,EACJxK,EAAI,EAAGA,EAAIqB,EAAGrB,IACnB,GAAIsK,IAAM1J,EAAOZ,GAAI,CACjBwK,GAAS,EACT,KACJ,CAECA,IACDH,GAAe,GAEnBzJ,EAAOS,GAAKiJ,CAChB,CAEJ,OAAO1J,CACX,EAoBAmB,EAAQoV,UAlBR,SAAmB5R,EAAGpB,EAAGC,GACrB,IAAIxB,EAAO,GAEPkD,EAAQ,EACZ,GAAIP,EAAE1D,SAAWsC,EAAIC,EACjB,MAAM,IAAIhB,MAAM,6CAEpB,IAAK,IAAI/B,EAAI,EAAGA,EAAI8C,EAAG9C,IAAK,CAExB,IADA,IAAIiC,EAAM,GACDgH,EAAI,EAAGA,EAAIlG,EAAGkG,IACnBhH,EAAI7B,KAAK8D,EAAEO,IACXA,GAAS,EAEblD,EAAKnB,KAAK6B,EAEd,CACA,OAAOV,CACX,C","sources":["webpack://eda/./node_modules/umap-js/dist/matrix.js","webpack://eda/./node_modules/umap-js/dist/heap.js","webpack://eda/./node_modules/umap-js/dist/nn_descent.js","webpack://eda/./node_modules/umap-js/dist/index.js","webpack://eda/./node_modules/umap-js/dist/tree.js","webpack://eda/./node_modules/umap-js/dist/umap.js","webpack://eda/./node_modules/umap-js/node_modules/is-any-array/src/index.js","webpack://eda/./node_modules/umap-js/node_modules/ml-levenberg-marquardt/src/errorCalculation.js","webpack://eda/./node_modules/umap-js/node_modules/ml-levenberg-marquardt/src/step.js","webpack://eda/./node_modules/umap-js/node_modules/ml-levenberg-marquardt/src/index.js","webpack://eda/./node_modules/umap-js/dist/utils.js"],"sourcesContent":["\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar _a;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getCSR = exports.normalize = exports.eliminateZeros = exports.multiplyScalar = exports.maximum = exports.subtract = exports.add = exports.pairwiseMultiply = exports.identity = exports.transpose = exports.SparseMatrix = void 0;\nvar utils = __importStar(require(\"./utils\"));\nvar SparseMatrix = (function () {\n    function SparseMatrix(rows, cols, values, dims) {\n        this.entries = new Map();\n        this.nRows = 0;\n        this.nCols = 0;\n        if (rows.length !== cols.length || rows.length !== values.length) {\n            throw new Error('rows, cols and values arrays must all have the same length');\n        }\n        this.nRows = dims[0];\n        this.nCols = dims[1];\n        for (var i = 0; i < values.length; i++) {\n            var row = rows[i];\n            var col = cols[i];\n            this.checkDims(row, col);\n            var key = this.makeKey(row, col);\n            this.entries.set(key, { value: values[i], row: row, col: col });\n        }\n    }\n    SparseMatrix.prototype.makeKey = function (row, col) {\n        return row + \":\" + col;\n    };\n    SparseMatrix.prototype.checkDims = function (row, col) {\n        var withinBounds = row < this.nRows && col < this.nCols;\n        if (!withinBounds) {\n            throw new Error('row and/or col specified outside of matrix dimensions');\n        }\n    };\n    SparseMatrix.prototype.set = function (row, col, value) {\n        this.checkDims(row, col);\n        var key = this.makeKey(row, col);\n        if (!this.entries.has(key)) {\n            this.entries.set(key, { value: value, row: row, col: col });\n        }\n        else {\n            this.entries.get(key).value = value;\n        }\n    };\n    SparseMatrix.prototype.get = function (row, col, defaultValue) {\n        if (defaultValue === void 0) { defaultValue = 0; }\n        this.checkDims(row, col);\n        var key = this.makeKey(row, col);\n        if (this.entries.has(key)) {\n            return this.entries.get(key).value;\n        }\n        else {\n            return defaultValue;\n        }\n    };\n    SparseMatrix.prototype.getAll = function (ordered) {\n        if (ordered === void 0) { ordered = true; }\n        var rowColValues = [];\n        this.entries.forEach(function (value) {\n            rowColValues.push(value);\n        });\n        if (ordered) {\n            rowColValues.sort(function (a, b) {\n                if (a.row === b.row) {\n                    return a.col - b.col;\n                }\n                else {\n                    return a.row - b.row;\n                }\n            });\n        }\n        return rowColValues;\n    };\n    SparseMatrix.prototype.getDims = function () {\n        return [this.nRows, this.nCols];\n    };\n    SparseMatrix.prototype.getRows = function () {\n        return Array.from(this.entries, function (_a) {\n            var _b = __read(_a, 2), key = _b[0], value = _b[1];\n            return value.row;\n        });\n    };\n    SparseMatrix.prototype.getCols = function () {\n        return Array.from(this.entries, function (_a) {\n            var _b = __read(_a, 2), key = _b[0], value = _b[1];\n            return value.col;\n        });\n    };\n    SparseMatrix.prototype.getValues = function () {\n        return Array.from(this.entries, function (_a) {\n            var _b = __read(_a, 2), key = _b[0], value = _b[1];\n            return value.value;\n        });\n    };\n    SparseMatrix.prototype.forEach = function (fn) {\n        this.entries.forEach(function (value) { return fn(value.value, value.row, value.col); });\n    };\n    SparseMatrix.prototype.map = function (fn) {\n        var vals = [];\n        this.entries.forEach(function (value) {\n            vals.push(fn(value.value, value.row, value.col));\n        });\n        var dims = [this.nRows, this.nCols];\n        return new SparseMatrix(this.getRows(), this.getCols(), vals, dims);\n    };\n    SparseMatrix.prototype.toArray = function () {\n        var _this = this;\n        var rows = utils.empty(this.nRows);\n        var output = rows.map(function () {\n            return utils.zeros(_this.nCols);\n        });\n        this.entries.forEach(function (value) {\n            output[value.row][value.col] = value.value;\n        });\n        return output;\n    };\n    return SparseMatrix;\n}());\nexports.SparseMatrix = SparseMatrix;\nfunction transpose(matrix) {\n    var cols = [];\n    var rows = [];\n    var vals = [];\n    matrix.forEach(function (value, row, col) {\n        cols.push(row);\n        rows.push(col);\n        vals.push(value);\n    });\n    var dims = [matrix.nCols, matrix.nRows];\n    return new SparseMatrix(rows, cols, vals, dims);\n}\nexports.transpose = transpose;\nfunction identity(size) {\n    var _a = __read(size, 1), rows = _a[0];\n    var matrix = new SparseMatrix([], [], [], size);\n    for (var i = 0; i < rows; i++) {\n        matrix.set(i, i, 1);\n    }\n    return matrix;\n}\nexports.identity = identity;\nfunction pairwiseMultiply(a, b) {\n    return elementWise(a, b, function (x, y) { return x * y; });\n}\nexports.pairwiseMultiply = pairwiseMultiply;\nfunction add(a, b) {\n    return elementWise(a, b, function (x, y) { return x + y; });\n}\nexports.add = add;\nfunction subtract(a, b) {\n    return elementWise(a, b, function (x, y) { return x - y; });\n}\nexports.subtract = subtract;\nfunction maximum(a, b) {\n    return elementWise(a, b, function (x, y) { return (x > y ? x : y); });\n}\nexports.maximum = maximum;\nfunction multiplyScalar(a, scalar) {\n    return a.map(function (value) {\n        return value * scalar;\n    });\n}\nexports.multiplyScalar = multiplyScalar;\nfunction eliminateZeros(m) {\n    var zeroIndices = new Set();\n    var values = m.getValues();\n    var rows = m.getRows();\n    var cols = m.getCols();\n    for (var i = 0; i < values.length; i++) {\n        if (values[i] === 0) {\n            zeroIndices.add(i);\n        }\n    }\n    var removeByZeroIndex = function (_, index) { return !zeroIndices.has(index); };\n    var nextValues = values.filter(removeByZeroIndex);\n    var nextRows = rows.filter(removeByZeroIndex);\n    var nextCols = cols.filter(removeByZeroIndex);\n    return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());\n}\nexports.eliminateZeros = eliminateZeros;\nfunction normalize(m, normType) {\n    var e_1, _a;\n    if (normType === void 0) { normType = \"l2\"; }\n    var normFn = normFns[normType];\n    var colsByRow = new Map();\n    m.forEach(function (_, row, col) {\n        var cols = colsByRow.get(row) || [];\n        cols.push(col);\n        colsByRow.set(row, cols);\n    });\n    var nextMatrix = new SparseMatrix([], [], [], m.getDims());\n    var _loop_1 = function (row) {\n        var cols = colsByRow.get(row).sort();\n        var vals = cols.map(function (col) { return m.get(row, col); });\n        var norm = normFn(vals);\n        for (var i = 0; i < norm.length; i++) {\n            nextMatrix.set(row, cols[i], norm[i]);\n        }\n    };\n    try {\n        for (var _b = __values(colsByRow.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var row = _c.value;\n            _loop_1(row);\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n    return nextMatrix;\n}\nexports.normalize = normalize;\nvar normFns = (_a = {},\n    _a[\"max\"] = function (xs) {\n        var max = -Infinity;\n        for (var i = 0; i < xs.length; i++) {\n            max = xs[i] > max ? xs[i] : max;\n        }\n        return xs.map(function (x) { return x / max; });\n    },\n    _a[\"l1\"] = function (xs) {\n        var sum = 0;\n        for (var i = 0; i < xs.length; i++) {\n            sum += xs[i];\n        }\n        return xs.map(function (x) { return x / sum; });\n    },\n    _a[\"l2\"] = function (xs) {\n        var sum = 0;\n        for (var i = 0; i < xs.length; i++) {\n            sum += Math.pow(xs[i], 2);\n        }\n        return xs.map(function (x) { return Math.sqrt(Math.pow(x, 2) / sum); });\n    },\n    _a);\nfunction elementWise(a, b, op) {\n    var visited = new Set();\n    var rows = [];\n    var cols = [];\n    var vals = [];\n    var operate = function (row, col) {\n        rows.push(row);\n        cols.push(col);\n        var nextValue = op(a.get(row, col), b.get(row, col));\n        vals.push(nextValue);\n    };\n    var valuesA = a.getValues();\n    var rowsA = a.getRows();\n    var colsA = a.getCols();\n    for (var i = 0; i < valuesA.length; i++) {\n        var row = rowsA[i];\n        var col = colsA[i];\n        var key = row + \":\" + col;\n        visited.add(key);\n        operate(row, col);\n    }\n    var valuesB = b.getValues();\n    var rowsB = b.getRows();\n    var colsB = b.getCols();\n    for (var i = 0; i < valuesB.length; i++) {\n        var row = rowsB[i];\n        var col = colsB[i];\n        var key = row + \":\" + col;\n        if (visited.has(key))\n            continue;\n        operate(row, col);\n    }\n    var dims = [a.nRows, a.nCols];\n    return new SparseMatrix(rows, cols, vals, dims);\n}\nfunction getCSR(x) {\n    var entries = [];\n    x.forEach(function (value, row, col) {\n        entries.push({ value: value, row: row, col: col });\n    });\n    entries.sort(function (a, b) {\n        if (a.row === b.row) {\n            return a.col - b.col;\n        }\n        else {\n            return a.row - b.row;\n        }\n    });\n    var indices = [];\n    var values = [];\n    var indptr = [];\n    var currentRow = -1;\n    for (var i = 0; i < entries.length; i++) {\n        var _a = entries[i], row = _a.row, col = _a.col, value = _a.value;\n        if (row !== currentRow) {\n            currentRow = row;\n            indptr.push(i);\n        }\n        indices.push(col);\n        values.push(value);\n    }\n    return { indices: indices, values: values, indptr: indptr };\n}\nexports.getCSR = getCSR;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.smallestFlagged = exports.deheapSort = exports.buildCandidates = exports.uncheckedHeapPush = exports.heapPush = exports.rejectionSample = exports.makeHeap = void 0;\nvar utils = __importStar(require(\"./utils\"));\nfunction makeHeap(nPoints, size) {\n    var makeArrays = function (fillValue) {\n        return utils.empty(nPoints).map(function () {\n            return utils.filled(size, fillValue);\n        });\n    };\n    var heap = [];\n    heap.push(makeArrays(-1));\n    heap.push(makeArrays(Infinity));\n    heap.push(makeArrays(0));\n    return heap;\n}\nexports.makeHeap = makeHeap;\nfunction rejectionSample(nSamples, poolSize, random) {\n    var result = utils.zeros(nSamples);\n    for (var i = 0; i < nSamples; i++) {\n        var rejectSample = true;\n        var j = 0;\n        while (rejectSample) {\n            j = utils.tauRandInt(poolSize, random);\n            var broken = false;\n            for (var k = 0; k < i; k++) {\n                if (j === result[k]) {\n                    broken = true;\n                    break;\n                }\n            }\n            if (!broken)\n                rejectSample = false;\n        }\n        result[i] = j;\n    }\n    return result;\n}\nexports.rejectionSample = rejectionSample;\nfunction heapPush(heap, row, weight, index, flag) {\n    row = Math.floor(row);\n    var indices = heap[0][row];\n    var weights = heap[1][row];\n    var isNew = heap[2][row];\n    if (weight >= weights[0]) {\n        return 0;\n    }\n    for (var i = 0; i < indices.length; i++) {\n        if (index === indices[i]) {\n            return 0;\n        }\n    }\n    return uncheckedHeapPush(heap, row, weight, index, flag);\n}\nexports.heapPush = heapPush;\nfunction uncheckedHeapPush(heap, row, weight, index, flag) {\n    var indices = heap[0][row];\n    var weights = heap[1][row];\n    var isNew = heap[2][row];\n    if (weight >= weights[0]) {\n        return 0;\n    }\n    weights[0] = weight;\n    indices[0] = index;\n    isNew[0] = flag;\n    var i = 0;\n    var iSwap = 0;\n    while (true) {\n        var ic1 = 2 * i + 1;\n        var ic2 = ic1 + 1;\n        var heapShape2 = heap[0][0].length;\n        if (ic1 >= heapShape2) {\n            break;\n        }\n        else if (ic2 >= heapShape2) {\n            if (weights[ic1] > weight) {\n                iSwap = ic1;\n            }\n            else {\n                break;\n            }\n        }\n        else if (weights[ic1] >= weights[ic2]) {\n            if (weight < weights[ic1]) {\n                iSwap = ic1;\n            }\n            else {\n                break;\n            }\n        }\n        else {\n            if (weight < weights[ic2]) {\n                iSwap = ic2;\n            }\n            else {\n                break;\n            }\n        }\n        weights[i] = weights[iSwap];\n        indices[i] = indices[iSwap];\n        isNew[i] = isNew[iSwap];\n        i = iSwap;\n    }\n    weights[i] = weight;\n    indices[i] = index;\n    isNew[i] = flag;\n    return 1;\n}\nexports.uncheckedHeapPush = uncheckedHeapPush;\nfunction buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random) {\n    var candidateNeighbors = makeHeap(nVertices, maxCandidates);\n    for (var i = 0; i < nVertices; i++) {\n        for (var j = 0; j < nNeighbors; j++) {\n            if (currentGraph[0][i][j] < 0) {\n                continue;\n            }\n            var idx = currentGraph[0][i][j];\n            var isn = currentGraph[2][i][j];\n            var d = utils.tauRand(random);\n            heapPush(candidateNeighbors, i, d, idx, isn);\n            heapPush(candidateNeighbors, idx, d, i, isn);\n            currentGraph[2][i][j] = 0;\n        }\n    }\n    return candidateNeighbors;\n}\nexports.buildCandidates = buildCandidates;\nfunction deheapSort(heap) {\n    var indices = heap[0];\n    var weights = heap[1];\n    for (var i = 0; i < indices.length; i++) {\n        var indHeap = indices[i];\n        var distHeap = weights[i];\n        for (var j = 0; j < indHeap.length - 1; j++) {\n            var indHeapIndex = indHeap.length - j - 1;\n            var distHeapIndex = distHeap.length - j - 1;\n            var temp1 = indHeap[0];\n            indHeap[0] = indHeap[indHeapIndex];\n            indHeap[indHeapIndex] = temp1;\n            var temp2 = distHeap[0];\n            distHeap[0] = distHeap[distHeapIndex];\n            distHeap[distHeapIndex] = temp2;\n            siftDown(distHeap, indHeap, distHeapIndex, 0);\n        }\n    }\n    return { indices: indices, weights: weights };\n}\nexports.deheapSort = deheapSort;\nfunction siftDown(heap1, heap2, ceiling, elt) {\n    while (elt * 2 + 1 < ceiling) {\n        var leftChild = elt * 2 + 1;\n        var rightChild = leftChild + 1;\n        var swap = elt;\n        if (heap1[swap] < heap1[leftChild]) {\n            swap = leftChild;\n        }\n        if (rightChild < ceiling && heap1[swap] < heap1[rightChild]) {\n            swap = rightChild;\n        }\n        if (swap === elt) {\n            break;\n        }\n        else {\n            var temp1 = heap1[elt];\n            heap1[elt] = heap1[swap];\n            heap1[swap] = temp1;\n            var temp2 = heap2[elt];\n            heap2[elt] = heap2[swap];\n            heap2[swap] = temp2;\n            elt = swap;\n        }\n    }\n}\nfunction smallestFlagged(heap, row) {\n    var ind = heap[0][row];\n    var dist = heap[1][row];\n    var flag = heap[2][row];\n    var minDist = Infinity;\n    var resultIndex = -1;\n    for (var i = 0; i > ind.length; i++) {\n        if (flag[i] === 1 && dist[i] < minDist) {\n            minDist = dist[i];\n            resultIndex = i;\n        }\n    }\n    if (resultIndex >= 0) {\n        flag[resultIndex] = 0;\n        return Math.floor(ind[resultIndex]);\n    }\n    else {\n        return -1;\n    }\n}\nexports.smallestFlagged = smallestFlagged;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.initializeSearch = exports.makeInitializedNNSearch = exports.makeInitializations = exports.makeNNDescent = void 0;\nvar heap = __importStar(require(\"./heap\"));\nvar matrix = __importStar(require(\"./matrix\"));\nvar tree = __importStar(require(\"./tree\"));\nvar utils = __importStar(require(\"./utils\"));\nfunction makeNNDescent(distanceFn, random) {\n    return function nNDescent(data, leafArray, nNeighbors, nIters, maxCandidates, delta, rho, rpTreeInit) {\n        if (nIters === void 0) { nIters = 10; }\n        if (maxCandidates === void 0) { maxCandidates = 50; }\n        if (delta === void 0) { delta = 0.001; }\n        if (rho === void 0) { rho = 0.5; }\n        if (rpTreeInit === void 0) { rpTreeInit = true; }\n        var nVertices = data.length;\n        var currentGraph = heap.makeHeap(data.length, nNeighbors);\n        for (var i = 0; i < data.length; i++) {\n            var indices = heap.rejectionSample(nNeighbors, data.length, random);\n            for (var j = 0; j < indices.length; j++) {\n                var d = distanceFn(data[i], data[indices[j]]);\n                heap.heapPush(currentGraph, i, d, indices[j], 1);\n                heap.heapPush(currentGraph, indices[j], d, i, 1);\n            }\n        }\n        if (rpTreeInit) {\n            for (var n = 0; n < leafArray.length; n++) {\n                for (var i = 0; i < leafArray[n].length; i++) {\n                    if (leafArray[n][i] < 0) {\n                        break;\n                    }\n                    for (var j = i + 1; j < leafArray[n].length; j++) {\n                        if (leafArray[n][j] < 0) {\n                            break;\n                        }\n                        var d = distanceFn(data[leafArray[n][i]], data[leafArray[n][j]]);\n                        heap.heapPush(currentGraph, leafArray[n][i], d, leafArray[n][j], 1);\n                        heap.heapPush(currentGraph, leafArray[n][j], d, leafArray[n][i], 1);\n                    }\n                }\n            }\n        }\n        for (var n = 0; n < nIters; n++) {\n            var candidateNeighbors = heap.buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random);\n            var c = 0;\n            for (var i = 0; i < nVertices; i++) {\n                for (var j = 0; j < maxCandidates; j++) {\n                    var p = Math.floor(candidateNeighbors[0][i][j]);\n                    if (p < 0 || utils.tauRand(random) < rho) {\n                        continue;\n                    }\n                    for (var k = 0; k < maxCandidates; k++) {\n                        var q = Math.floor(candidateNeighbors[0][i][k]);\n                        var cj = candidateNeighbors[2][i][j];\n                        var ck = candidateNeighbors[2][i][k];\n                        if (q < 0 || (!cj && !ck)) {\n                            continue;\n                        }\n                        var d = distanceFn(data[p], data[q]);\n                        c += heap.heapPush(currentGraph, p, d, q, 1);\n                        c += heap.heapPush(currentGraph, q, d, p, 1);\n                    }\n                }\n            }\n            if (c <= delta * nNeighbors * data.length) {\n                break;\n            }\n        }\n        var sorted = heap.deheapSort(currentGraph);\n        return sorted;\n    };\n}\nexports.makeNNDescent = makeNNDescent;\nfunction makeInitializations(distanceFn) {\n    function initFromRandom(nNeighbors, data, queryPoints, _heap, random) {\n        for (var i = 0; i < queryPoints.length; i++) {\n            var indices = utils.rejectionSample(nNeighbors, data.length, random);\n            for (var j = 0; j < indices.length; j++) {\n                if (indices[j] < 0) {\n                    continue;\n                }\n                var d = distanceFn(data[indices[j]], queryPoints[i]);\n                heap.heapPush(_heap, i, d, indices[j], 1);\n            }\n        }\n    }\n    function initFromTree(_tree, data, queryPoints, _heap, random) {\n        for (var i = 0; i < queryPoints.length; i++) {\n            var indices = tree.searchFlatTree(queryPoints[i], _tree, random);\n            for (var j = 0; j < indices.length; j++) {\n                if (indices[j] < 0) {\n                    return;\n                }\n                var d = distanceFn(data[indices[j]], queryPoints[i]);\n                heap.heapPush(_heap, i, d, indices[j], 1);\n            }\n        }\n        return;\n    }\n    return { initFromRandom: initFromRandom, initFromTree: initFromTree };\n}\nexports.makeInitializations = makeInitializations;\nfunction makeInitializedNNSearch(distanceFn) {\n    return function nnSearchFn(data, graph, initialization, queryPoints) {\n        var e_1, _a;\n        var _b = matrix.getCSR(graph), indices = _b.indices, indptr = _b.indptr;\n        for (var i = 0; i < queryPoints.length; i++) {\n            var tried = new Set(initialization[0][i]);\n            while (true) {\n                var vertex = heap.smallestFlagged(initialization, i);\n                if (vertex === -1) {\n                    break;\n                }\n                var candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);\n                try {\n                    for (var candidates_1 = (e_1 = void 0, __values(candidates)), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {\n                        var candidate = candidates_1_1.value;\n                        if (candidate === vertex ||\n                            candidate === -1 ||\n                            tried.has(candidate)) {\n                            continue;\n                        }\n                        var d = distanceFn(data[candidate], queryPoints[i]);\n                        heap.uncheckedHeapPush(initialization, i, d, candidate, 1);\n                        tried.add(candidate);\n                    }\n                }\n                catch (e_1_1) { e_1 = { error: e_1_1 }; }\n                finally {\n                    try {\n                        if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);\n                    }\n                    finally { if (e_1) throw e_1.error; }\n                }\n            }\n        }\n        return initialization;\n    };\n}\nexports.makeInitializedNNSearch = makeInitializedNNSearch;\nfunction initializeSearch(forest, data, queryPoints, nNeighbors, initFromRandom, initFromTree, random) {\n    var e_2, _a;\n    var results = heap.makeHeap(queryPoints.length, nNeighbors);\n    initFromRandom(nNeighbors, data, queryPoints, results, random);\n    if (forest) {\n        try {\n            for (var forest_1 = __values(forest), forest_1_1 = forest_1.next(); !forest_1_1.done; forest_1_1 = forest_1.next()) {\n                var tree_1 = forest_1_1.value;\n                initFromTree(tree_1, data, queryPoints, results, random);\n            }\n        }\n        catch (e_2_1) { e_2 = { error: e_2_1 }; }\n        finally {\n            try {\n                if (forest_1_1 && !forest_1_1.done && (_a = forest_1.return)) _a.call(forest_1);\n            }\n            finally { if (e_2) throw e_2.error; }\n        }\n    }\n    return results;\n}\nexports.initializeSearch = initializeSearch;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar umap_1 = require(\"./umap\");\nObject.defineProperty(exports, \"UMAP\", { enumerable: true, get: function () { return umap_1.UMAP; } });\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spread = (this && this.__spread) || function () {\n    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n    return ar;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.searchFlatTree = exports.makeLeafArray = exports.makeForest = exports.FlatTree = void 0;\nvar utils = __importStar(require(\"./utils\"));\nvar FlatTree = (function () {\n    function FlatTree(hyperplanes, offsets, children, indices) {\n        this.hyperplanes = hyperplanes;\n        this.offsets = offsets;\n        this.children = children;\n        this.indices = indices;\n    }\n    return FlatTree;\n}());\nexports.FlatTree = FlatTree;\nfunction makeForest(data, nNeighbors, nTrees, random) {\n    var leafSize = Math.max(10, nNeighbors);\n    var trees = utils\n        .range(nTrees)\n        .map(function (_, i) { return makeTree(data, leafSize, i, random); });\n    var forest = trees.map(function (tree) { return flattenTree(tree, leafSize); });\n    return forest;\n}\nexports.makeForest = makeForest;\nfunction makeTree(data, leafSize, n, random) {\n    if (leafSize === void 0) { leafSize = 30; }\n    var indices = utils.range(data.length);\n    var tree = makeEuclideanTree(data, indices, leafSize, n, random);\n    return tree;\n}\nfunction makeEuclideanTree(data, indices, leafSize, q, random) {\n    if (leafSize === void 0) { leafSize = 30; }\n    if (indices.length > leafSize) {\n        var splitResults = euclideanRandomProjectionSplit(data, indices, random);\n        var indicesLeft = splitResults.indicesLeft, indicesRight = splitResults.indicesRight, hyperplane = splitResults.hyperplane, offset = splitResults.offset;\n        var leftChild = makeEuclideanTree(data, indicesLeft, leafSize, q + 1, random);\n        var rightChild = makeEuclideanTree(data, indicesRight, leafSize, q + 1, random);\n        var node = { leftChild: leftChild, rightChild: rightChild, isLeaf: false, hyperplane: hyperplane, offset: offset };\n        return node;\n    }\n    else {\n        var node = { indices: indices, isLeaf: true };\n        return node;\n    }\n}\nfunction euclideanRandomProjectionSplit(data, indices, random) {\n    var dim = data[0].length;\n    var leftIndex = utils.tauRandInt(indices.length, random);\n    var rightIndex = utils.tauRandInt(indices.length, random);\n    rightIndex += leftIndex === rightIndex ? 1 : 0;\n    rightIndex = rightIndex % indices.length;\n    var left = indices[leftIndex];\n    var right = indices[rightIndex];\n    var hyperplaneOffset = 0;\n    var hyperplaneVector = utils.zeros(dim);\n    for (var i = 0; i < hyperplaneVector.length; i++) {\n        hyperplaneVector[i] = data[left][i] - data[right][i];\n        hyperplaneOffset -=\n            (hyperplaneVector[i] * (data[left][i] + data[right][i])) / 2.0;\n    }\n    var nLeft = 0;\n    var nRight = 0;\n    var side = utils.zeros(indices.length);\n    for (var i = 0; i < indices.length; i++) {\n        var margin = hyperplaneOffset;\n        for (var d = 0; d < dim; d++) {\n            margin += hyperplaneVector[d] * data[indices[i]][d];\n        }\n        if (margin === 0) {\n            side[i] = utils.tauRandInt(2, random);\n            if (side[i] === 0) {\n                nLeft += 1;\n            }\n            else {\n                nRight += 1;\n            }\n        }\n        else if (margin > 0) {\n            side[i] = 0;\n            nLeft += 1;\n        }\n        else {\n            side[i] = 1;\n            nRight += 1;\n        }\n    }\n    var indicesLeft = utils.zeros(nLeft);\n    var indicesRight = utils.zeros(nRight);\n    nLeft = 0;\n    nRight = 0;\n    for (var i = 0; i < side.length; i++) {\n        if (side[i] === 0) {\n            indicesLeft[nLeft] = indices[i];\n            nLeft += 1;\n        }\n        else {\n            indicesRight[nRight] = indices[i];\n            nRight += 1;\n        }\n    }\n    return {\n        indicesLeft: indicesLeft,\n        indicesRight: indicesRight,\n        hyperplane: hyperplaneVector,\n        offset: hyperplaneOffset,\n    };\n}\nfunction flattenTree(tree, leafSize) {\n    var nNodes = numNodes(tree);\n    var nLeaves = numLeaves(tree);\n    var hyperplanes = utils\n        .range(nNodes)\n        .map(function () { return utils.zeros(tree.hyperplane ? tree.hyperplane.length : 0); });\n    var offsets = utils.zeros(nNodes);\n    var children = utils.range(nNodes).map(function () { return [-1, -1]; });\n    var indices = utils\n        .range(nLeaves)\n        .map(function () { return utils.range(leafSize).map(function () { return -1; }); });\n    recursiveFlatten(tree, hyperplanes, offsets, children, indices, 0, 0);\n    return new FlatTree(hyperplanes, offsets, children, indices);\n}\nfunction recursiveFlatten(tree, hyperplanes, offsets, children, indices, nodeNum, leafNum) {\n    var _a;\n    if (tree.isLeaf) {\n        children[nodeNum][0] = -leafNum;\n        (_a = indices[leafNum]).splice.apply(_a, __spread([0, tree.indices.length], tree.indices));\n        leafNum += 1;\n        return { nodeNum: nodeNum, leafNum: leafNum };\n    }\n    else {\n        hyperplanes[nodeNum] = tree.hyperplane;\n        offsets[nodeNum] = tree.offset;\n        children[nodeNum][0] = nodeNum + 1;\n        var oldNodeNum = nodeNum;\n        var res = recursiveFlatten(tree.leftChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n        nodeNum = res.nodeNum;\n        leafNum = res.leafNum;\n        children[oldNodeNum][1] = nodeNum + 1;\n        res = recursiveFlatten(tree.rightChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n        return { nodeNum: res.nodeNum, leafNum: res.leafNum };\n    }\n}\nfunction numNodes(tree) {\n    if (tree.isLeaf) {\n        return 1;\n    }\n    else {\n        return 1 + numNodes(tree.leftChild) + numNodes(tree.rightChild);\n    }\n}\nfunction numLeaves(tree) {\n    if (tree.isLeaf) {\n        return 1;\n    }\n    else {\n        return numLeaves(tree.leftChild) + numLeaves(tree.rightChild);\n    }\n}\nfunction makeLeafArray(rpForest) {\n    var e_1, _a;\n    if (rpForest.length > 0) {\n        var output = [];\n        try {\n            for (var rpForest_1 = __values(rpForest), rpForest_1_1 = rpForest_1.next(); !rpForest_1_1.done; rpForest_1_1 = rpForest_1.next()) {\n                var tree = rpForest_1_1.value;\n                output.push.apply(output, __spread(tree.indices));\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (rpForest_1_1 && !rpForest_1_1.done && (_a = rpForest_1.return)) _a.call(rpForest_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return output;\n    }\n    else {\n        return [[-1]];\n    }\n}\nexports.makeLeafArray = makeLeafArray;\nfunction selectSide(hyperplane, offset, point, random) {\n    var margin = offset;\n    for (var d = 0; d < point.length; d++) {\n        margin += hyperplane[d] * point[d];\n    }\n    if (margin === 0) {\n        var side = utils.tauRandInt(2, random);\n        return side;\n    }\n    else if (margin > 0) {\n        return 0;\n    }\n    else {\n        return 1;\n    }\n}\nfunction searchFlatTree(point, tree, random) {\n    var node = 0;\n    while (tree.children[node][0] > 0) {\n        var side = selectSide(tree.hyperplanes[node], tree.offsets[node], point, random);\n        if (side === 0) {\n            node = tree.children[node][0];\n        }\n        else {\n            node = tree.children[node][1];\n        }\n    }\n    var index = -1 * tree.children[node][0];\n    return tree.indices[index];\n}\nexports.searchFlatTree = searchFlatTree;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spread = (this && this.__spread) || function () {\n    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n    return ar;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.initTransform = exports.resetLocalConnectivity = exports.fastIntersection = exports.findABParams = exports.cosine = exports.euclidean = exports.UMAP = void 0;\nvar heap = __importStar(require(\"./heap\"));\nvar matrix = __importStar(require(\"./matrix\"));\nvar nnDescent = __importStar(require(\"./nn_descent\"));\nvar tree = __importStar(require(\"./tree\"));\nvar utils = __importStar(require(\"./utils\"));\nvar ml_levenberg_marquardt_1 = __importDefault(require(\"ml-levenberg-marquardt\"));\nvar SMOOTH_K_TOLERANCE = 1e-5;\nvar MIN_K_DIST_SCALE = 1e-3;\nvar UMAP = (function () {\n    function UMAP(params) {\n        var _this = this;\n        if (params === void 0) { params = {}; }\n        this.learningRate = 1.0;\n        this.localConnectivity = 1.0;\n        this.minDist = 0.1;\n        this.nComponents = 2;\n        this.nEpochs = 0;\n        this.nNeighbors = 15;\n        this.negativeSampleRate = 5;\n        this.random = Math.random;\n        this.repulsionStrength = 1.0;\n        this.setOpMixRatio = 1.0;\n        this.spread = 1.0;\n        this.transformQueueSize = 4.0;\n        this.targetMetric = \"categorical\";\n        this.targetWeight = 0.5;\n        this.targetNNeighbors = this.nNeighbors;\n        this.distanceFn = euclidean;\n        this.isInitialized = false;\n        this.rpForest = [];\n        this.embedding = [];\n        this.optimizationState = new OptimizationState();\n        var setParam = function (key) {\n            if (params[key] !== undefined)\n                _this[key] = params[key];\n        };\n        setParam('distanceFn');\n        setParam('learningRate');\n        setParam('localConnectivity');\n        setParam('minDist');\n        setParam('nComponents');\n        setParam('nEpochs');\n        setParam('nNeighbors');\n        setParam('negativeSampleRate');\n        setParam('random');\n        setParam('repulsionStrength');\n        setParam('setOpMixRatio');\n        setParam('spread');\n        setParam('transformQueueSize');\n    }\n    UMAP.prototype.fit = function (X) {\n        this.initializeFit(X);\n        this.optimizeLayout();\n        return this.embedding;\n    };\n    UMAP.prototype.fitAsync = function (X, callback) {\n        if (callback === void 0) { callback = function () { return true; }; }\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        this.initializeFit(X);\n                        return [4, this.optimizeLayoutAsync(callback)];\n                    case 1:\n                        _a.sent();\n                        return [2, this.embedding];\n                }\n            });\n        });\n    };\n    UMAP.prototype.setSupervisedProjection = function (Y, params) {\n        if (params === void 0) { params = {}; }\n        this.Y = Y;\n        this.targetMetric = params.targetMetric || this.targetMetric;\n        this.targetWeight = params.targetWeight || this.targetWeight;\n        this.targetNNeighbors = params.targetNNeighbors || this.targetNNeighbors;\n    };\n    UMAP.prototype.setPrecomputedKNN = function (knnIndices, knnDistances) {\n        this.knnIndices = knnIndices;\n        this.knnDistances = knnDistances;\n    };\n    UMAP.prototype.initializeFit = function (X) {\n        if (X.length <= this.nNeighbors) {\n            throw new Error(\"Not enough data points (\" + X.length + \") to create nNeighbors: \" + this.nNeighbors + \".  Add more data points or adjust the configuration.\");\n        }\n        if (this.X === X && this.isInitialized) {\n            return this.getNEpochs();\n        }\n        this.X = X;\n        if (!this.knnIndices && !this.knnDistances) {\n            var knnResults = this.nearestNeighbors(X);\n            this.knnIndices = knnResults.knnIndices;\n            this.knnDistances = knnResults.knnDistances;\n        }\n        this.graph = this.fuzzySimplicialSet(X, this.nNeighbors, this.setOpMixRatio);\n        this.makeSearchFns();\n        this.searchGraph = this.makeSearchGraph(X);\n        this.processGraphForSupervisedProjection();\n        var _a = this.initializeSimplicialSetEmbedding(), head = _a.head, tail = _a.tail, epochsPerSample = _a.epochsPerSample;\n        this.optimizationState.head = head;\n        this.optimizationState.tail = tail;\n        this.optimizationState.epochsPerSample = epochsPerSample;\n        this.initializeOptimization();\n        this.prepareForOptimizationLoop();\n        this.isInitialized = true;\n        return this.getNEpochs();\n    };\n    UMAP.prototype.makeSearchFns = function () {\n        var _a = nnDescent.makeInitializations(this.distanceFn), initFromTree = _a.initFromTree, initFromRandom = _a.initFromRandom;\n        this.initFromTree = initFromTree;\n        this.initFromRandom = initFromRandom;\n        this.search = nnDescent.makeInitializedNNSearch(this.distanceFn);\n    };\n    UMAP.prototype.makeSearchGraph = function (X) {\n        var knnIndices = this.knnIndices;\n        var knnDistances = this.knnDistances;\n        var dims = [X.length, X.length];\n        var searchGraph = new matrix.SparseMatrix([], [], [], dims);\n        for (var i = 0; i < knnIndices.length; i++) {\n            var knn = knnIndices[i];\n            var distances = knnDistances[i];\n            for (var j = 0; j < knn.length; j++) {\n                var neighbor = knn[j];\n                var distance = distances[j];\n                if (distance > 0) {\n                    searchGraph.set(i, neighbor, distance);\n                }\n            }\n        }\n        var transpose = matrix.transpose(searchGraph);\n        return matrix.maximum(searchGraph, transpose);\n    };\n    UMAP.prototype.transform = function (toTransform) {\n        var _this = this;\n        var rawData = this.X;\n        if (rawData === undefined || rawData.length === 0) {\n            throw new Error('No data has been fit.');\n        }\n        var nNeighbors = Math.floor(this.nNeighbors * this.transformQueueSize);\n        nNeighbors = Math.min(rawData.length, nNeighbors);\n        var init = nnDescent.initializeSearch(this.rpForest, rawData, toTransform, nNeighbors, this.initFromRandom, this.initFromTree, this.random);\n        var result = this.search(rawData, this.searchGraph, init, toTransform);\n        var _a = heap.deheapSort(result), indices = _a.indices, distances = _a.weights;\n        indices = indices.map(function (x) { return x.slice(0, _this.nNeighbors); });\n        distances = distances.map(function (x) { return x.slice(0, _this.nNeighbors); });\n        var adjustedLocalConnectivity = Math.max(0, this.localConnectivity - 1);\n        var _b = this.smoothKNNDistance(distances, this.nNeighbors, adjustedLocalConnectivity), sigmas = _b.sigmas, rhos = _b.rhos;\n        var _c = this.computeMembershipStrengths(indices, distances, sigmas, rhos), rows = _c.rows, cols = _c.cols, vals = _c.vals;\n        var size = [toTransform.length, rawData.length];\n        var graph = new matrix.SparseMatrix(rows, cols, vals, size);\n        var normed = matrix.normalize(graph, \"l1\");\n        var csrMatrix = matrix.getCSR(normed);\n        var nPoints = toTransform.length;\n        var eIndices = utils.reshape2d(csrMatrix.indices, nPoints, this.nNeighbors);\n        var eWeights = utils.reshape2d(csrMatrix.values, nPoints, this.nNeighbors);\n        var embedding = initTransform(eIndices, eWeights, this.embedding);\n        var nEpochs = this.nEpochs\n            ? this.nEpochs / 3\n            : graph.nRows <= 10000\n                ? 100\n                : 30;\n        var graphMax = graph\n            .getValues()\n            .reduce(function (max, val) { return (val > max ? val : max); }, 0);\n        graph = graph.map(function (value) { return (value < graphMax / nEpochs ? 0 : value); });\n        graph = matrix.eliminateZeros(graph);\n        var epochsPerSample = this.makeEpochsPerSample(graph.getValues(), nEpochs);\n        var head = graph.getRows();\n        var tail = graph.getCols();\n        this.assignOptimizationStateParameters({\n            headEmbedding: embedding,\n            tailEmbedding: this.embedding,\n            head: head,\n            tail: tail,\n            currentEpoch: 0,\n            nEpochs: nEpochs,\n            nVertices: graph.getDims()[1],\n            epochsPerSample: epochsPerSample,\n        });\n        this.prepareForOptimizationLoop();\n        return this.optimizeLayout();\n    };\n    UMAP.prototype.processGraphForSupervisedProjection = function () {\n        var _a = this, Y = _a.Y, X = _a.X;\n        if (Y) {\n            if (Y.length !== X.length) {\n                throw new Error('Length of X and y must be equal');\n            }\n            if (this.targetMetric === \"categorical\") {\n                var lt = this.targetWeight < 1.0;\n                var farDist = lt ? 2.5 * (1.0 / (1.0 - this.targetWeight)) : 1.0e12;\n                this.graph = this.categoricalSimplicialSetIntersection(this.graph, Y, farDist);\n            }\n        }\n    };\n    UMAP.prototype.step = function () {\n        var currentEpoch = this.optimizationState.currentEpoch;\n        if (currentEpoch < this.getNEpochs()) {\n            this.optimizeLayoutStep(currentEpoch);\n        }\n        return this.optimizationState.currentEpoch;\n    };\n    UMAP.prototype.getEmbedding = function () {\n        return this.embedding;\n    };\n    UMAP.prototype.nearestNeighbors = function (X) {\n        var _a = this, distanceFn = _a.distanceFn, nNeighbors = _a.nNeighbors;\n        var log2 = function (n) { return Math.log(n) / Math.log(2); };\n        var metricNNDescent = nnDescent.makeNNDescent(distanceFn, this.random);\n        var round = function (n) {\n            return n === 0.5 ? 0 : Math.round(n);\n        };\n        var nTrees = 5 + Math.floor(round(Math.pow(X.length, 0.5) / 20.0));\n        var nIters = Math.max(5, Math.floor(Math.round(log2(X.length))));\n        this.rpForest = tree.makeForest(X, nNeighbors, nTrees, this.random);\n        var leafArray = tree.makeLeafArray(this.rpForest);\n        var _b = metricNNDescent(X, leafArray, nNeighbors, nIters), indices = _b.indices, weights = _b.weights;\n        return { knnIndices: indices, knnDistances: weights };\n    };\n    UMAP.prototype.fuzzySimplicialSet = function (X, nNeighbors, setOpMixRatio) {\n        if (setOpMixRatio === void 0) { setOpMixRatio = 1.0; }\n        var _a = this, _b = _a.knnIndices, knnIndices = _b === void 0 ? [] : _b, _c = _a.knnDistances, knnDistances = _c === void 0 ? [] : _c, localConnectivity = _a.localConnectivity;\n        var _d = this.smoothKNNDistance(knnDistances, nNeighbors, localConnectivity), sigmas = _d.sigmas, rhos = _d.rhos;\n        var _e = this.computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos), rows = _e.rows, cols = _e.cols, vals = _e.vals;\n        var size = [X.length, X.length];\n        var sparseMatrix = new matrix.SparseMatrix(rows, cols, vals, size);\n        var transpose = matrix.transpose(sparseMatrix);\n        var prodMatrix = matrix.pairwiseMultiply(sparseMatrix, transpose);\n        var a = matrix.subtract(matrix.add(sparseMatrix, transpose), prodMatrix);\n        var b = matrix.multiplyScalar(a, setOpMixRatio);\n        var c = matrix.multiplyScalar(prodMatrix, 1.0 - setOpMixRatio);\n        var result = matrix.add(b, c);\n        return result;\n    };\n    UMAP.prototype.categoricalSimplicialSetIntersection = function (simplicialSet, target, farDist, unknownDist) {\n        if (unknownDist === void 0) { unknownDist = 1.0; }\n        var intersection = fastIntersection(simplicialSet, target, unknownDist, farDist);\n        intersection = matrix.eliminateZeros(intersection);\n        return resetLocalConnectivity(intersection);\n    };\n    UMAP.prototype.smoothKNNDistance = function (distances, k, localConnectivity, nIter, bandwidth) {\n        if (localConnectivity === void 0) { localConnectivity = 1.0; }\n        if (nIter === void 0) { nIter = 64; }\n        if (bandwidth === void 0) { bandwidth = 1.0; }\n        var target = (Math.log(k) / Math.log(2)) * bandwidth;\n        var rho = utils.zeros(distances.length);\n        var result = utils.zeros(distances.length);\n        for (var i = 0; i < distances.length; i++) {\n            var lo = 0.0;\n            var hi = Infinity;\n            var mid = 1.0;\n            var ithDistances = distances[i];\n            var nonZeroDists = ithDistances.filter(function (d) { return d > 0.0; });\n            if (nonZeroDists.length >= localConnectivity) {\n                var index = Math.floor(localConnectivity);\n                var interpolation = localConnectivity - index;\n                if (index > 0) {\n                    rho[i] = nonZeroDists[index - 1];\n                    if (interpolation > SMOOTH_K_TOLERANCE) {\n                        rho[i] +=\n                            interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n                    }\n                }\n                else {\n                    rho[i] = interpolation * nonZeroDists[0];\n                }\n            }\n            else if (nonZeroDists.length > 0) {\n                rho[i] = utils.max(nonZeroDists);\n            }\n            for (var n = 0; n < nIter; n++) {\n                var psum = 0.0;\n                for (var j = 1; j < distances[i].length; j++) {\n                    var d = distances[i][j] - rho[i];\n                    if (d > 0) {\n                        psum += Math.exp(-(d / mid));\n                    }\n                    else {\n                        psum += 1.0;\n                    }\n                }\n                if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE) {\n                    break;\n                }\n                if (psum > target) {\n                    hi = mid;\n                    mid = (lo + hi) / 2.0;\n                }\n                else {\n                    lo = mid;\n                    if (hi === Infinity) {\n                        mid *= 2;\n                    }\n                    else {\n                        mid = (lo + hi) / 2.0;\n                    }\n                }\n            }\n            result[i] = mid;\n            if (rho[i] > 0.0) {\n                var meanIthDistances = utils.mean(ithDistances);\n                if (result[i] < MIN_K_DIST_SCALE * meanIthDistances) {\n                    result[i] = MIN_K_DIST_SCALE * meanIthDistances;\n                }\n            }\n            else {\n                var meanDistances = utils.mean(distances.map(utils.mean));\n                if (result[i] < MIN_K_DIST_SCALE * meanDistances) {\n                    result[i] = MIN_K_DIST_SCALE * meanDistances;\n                }\n            }\n        }\n        return { sigmas: result, rhos: rho };\n    };\n    UMAP.prototype.computeMembershipStrengths = function (knnIndices, knnDistances, sigmas, rhos) {\n        var nSamples = knnIndices.length;\n        var nNeighbors = knnIndices[0].length;\n        var rows = utils.zeros(nSamples * nNeighbors);\n        var cols = utils.zeros(nSamples * nNeighbors);\n        var vals = utils.zeros(nSamples * nNeighbors);\n        for (var i = 0; i < nSamples; i++) {\n            for (var j = 0; j < nNeighbors; j++) {\n                var val = 0;\n                if (knnIndices[i][j] === -1) {\n                    continue;\n                }\n                if (knnIndices[i][j] === i) {\n                    val = 0.0;\n                }\n                else if (knnDistances[i][j] - rhos[i] <= 0.0) {\n                    val = 1.0;\n                }\n                else {\n                    val = Math.exp(-((knnDistances[i][j] - rhos[i]) / sigmas[i]));\n                }\n                rows[i * nNeighbors + j] = i;\n                cols[i * nNeighbors + j] = knnIndices[i][j];\n                vals[i * nNeighbors + j] = val;\n            }\n        }\n        return { rows: rows, cols: cols, vals: vals };\n    };\n    UMAP.prototype.initializeSimplicialSetEmbedding = function () {\n        var _this = this;\n        var nEpochs = this.getNEpochs();\n        var nComponents = this.nComponents;\n        var graphValues = this.graph.getValues();\n        var graphMax = 0;\n        for (var i = 0; i < graphValues.length; i++) {\n            var value = graphValues[i];\n            if (graphMax < graphValues[i]) {\n                graphMax = value;\n            }\n        }\n        var graph = this.graph.map(function (value) {\n            if (value < graphMax / nEpochs) {\n                return 0;\n            }\n            else {\n                return value;\n            }\n        });\n        this.embedding = utils.zeros(graph.nRows).map(function () {\n            return utils.zeros(nComponents).map(function () {\n                return utils.tauRand(_this.random) * 20 + -10;\n            });\n        });\n        var weights = [];\n        var head = [];\n        var tail = [];\n        var rowColValues = graph.getAll();\n        for (var i = 0; i < rowColValues.length; i++) {\n            var entry = rowColValues[i];\n            if (entry.value) {\n                weights.push(entry.value);\n                tail.push(entry.row);\n                head.push(entry.col);\n            }\n        }\n        var epochsPerSample = this.makeEpochsPerSample(weights, nEpochs);\n        return { head: head, tail: tail, epochsPerSample: epochsPerSample };\n    };\n    UMAP.prototype.makeEpochsPerSample = function (weights, nEpochs) {\n        var result = utils.filled(weights.length, -1.0);\n        var max = utils.max(weights);\n        var nSamples = weights.map(function (w) { return (w / max) * nEpochs; });\n        nSamples.forEach(function (n, i) {\n            if (n > 0)\n                result[i] = nEpochs / nSamples[i];\n        });\n        return result;\n    };\n    UMAP.prototype.assignOptimizationStateParameters = function (state) {\n        Object.assign(this.optimizationState, state);\n    };\n    UMAP.prototype.prepareForOptimizationLoop = function () {\n        var _a = this, repulsionStrength = _a.repulsionStrength, learningRate = _a.learningRate, negativeSampleRate = _a.negativeSampleRate;\n        var _b = this.optimizationState, epochsPerSample = _b.epochsPerSample, headEmbedding = _b.headEmbedding, tailEmbedding = _b.tailEmbedding;\n        var dim = headEmbedding[0].length;\n        var moveOther = headEmbedding.length === tailEmbedding.length;\n        var epochsPerNegativeSample = epochsPerSample.map(function (e) { return e / negativeSampleRate; });\n        var epochOfNextNegativeSample = __spread(epochsPerNegativeSample);\n        var epochOfNextSample = __spread(epochsPerSample);\n        this.assignOptimizationStateParameters({\n            epochOfNextSample: epochOfNextSample,\n            epochOfNextNegativeSample: epochOfNextNegativeSample,\n            epochsPerNegativeSample: epochsPerNegativeSample,\n            moveOther: moveOther,\n            initialAlpha: learningRate,\n            alpha: learningRate,\n            gamma: repulsionStrength,\n            dim: dim,\n        });\n    };\n    UMAP.prototype.initializeOptimization = function () {\n        var headEmbedding = this.embedding;\n        var tailEmbedding = this.embedding;\n        var _a = this.optimizationState, head = _a.head, tail = _a.tail, epochsPerSample = _a.epochsPerSample;\n        var nEpochs = this.getNEpochs();\n        var nVertices = this.graph.nCols;\n        var _b = findABParams(this.spread, this.minDist), a = _b.a, b = _b.b;\n        this.assignOptimizationStateParameters({\n            headEmbedding: headEmbedding,\n            tailEmbedding: tailEmbedding,\n            head: head,\n            tail: tail,\n            epochsPerSample: epochsPerSample,\n            a: a,\n            b: b,\n            nEpochs: nEpochs,\n            nVertices: nVertices,\n        });\n    };\n    UMAP.prototype.optimizeLayoutStep = function (n) {\n        var optimizationState = this.optimizationState;\n        var head = optimizationState.head, tail = optimizationState.tail, headEmbedding = optimizationState.headEmbedding, tailEmbedding = optimizationState.tailEmbedding, epochsPerSample = optimizationState.epochsPerSample, epochOfNextSample = optimizationState.epochOfNextSample, epochOfNextNegativeSample = optimizationState.epochOfNextNegativeSample, epochsPerNegativeSample = optimizationState.epochsPerNegativeSample, moveOther = optimizationState.moveOther, initialAlpha = optimizationState.initialAlpha, alpha = optimizationState.alpha, gamma = optimizationState.gamma, a = optimizationState.a, b = optimizationState.b, dim = optimizationState.dim, nEpochs = optimizationState.nEpochs, nVertices = optimizationState.nVertices;\n        var clipValue = 4.0;\n        for (var i = 0; i < epochsPerSample.length; i++) {\n            if (epochOfNextSample[i] > n) {\n                continue;\n            }\n            var j = head[i];\n            var k = tail[i];\n            var current = headEmbedding[j];\n            var other = tailEmbedding[k];\n            var distSquared = rDist(current, other);\n            var gradCoeff = 0;\n            if (distSquared > 0) {\n                gradCoeff = -2.0 * a * b * Math.pow(distSquared, b - 1.0);\n                gradCoeff /= a * Math.pow(distSquared, b) + 1.0;\n            }\n            for (var d = 0; d < dim; d++) {\n                var gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n                current[d] += gradD * alpha;\n                if (moveOther) {\n                    other[d] += -gradD * alpha;\n                }\n            }\n            epochOfNextSample[i] += epochsPerSample[i];\n            var nNegSamples = Math.floor((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);\n            for (var p = 0; p < nNegSamples; p++) {\n                var k_1 = utils.tauRandInt(nVertices, this.random);\n                var other_1 = tailEmbedding[k_1];\n                var distSquared_1 = rDist(current, other_1);\n                var gradCoeff_1 = 0.0;\n                if (distSquared_1 > 0.0) {\n                    gradCoeff_1 = 2.0 * gamma * b;\n                    gradCoeff_1 /=\n                        (0.001 + distSquared_1) * (a * Math.pow(distSquared_1, b) + 1);\n                }\n                else if (j === k_1) {\n                    continue;\n                }\n                for (var d = 0; d < dim; d++) {\n                    var gradD = 4.0;\n                    if (gradCoeff_1 > 0.0) {\n                        gradD = clip(gradCoeff_1 * (current[d] - other_1[d]), clipValue);\n                    }\n                    current[d] += gradD * alpha;\n                }\n            }\n            epochOfNextNegativeSample[i] += nNegSamples * epochsPerNegativeSample[i];\n        }\n        optimizationState.alpha = initialAlpha * (1.0 - n / nEpochs);\n        optimizationState.currentEpoch += 1;\n        return headEmbedding;\n    };\n    UMAP.prototype.optimizeLayoutAsync = function (epochCallback) {\n        var _this = this;\n        if (epochCallback === void 0) { epochCallback = function () { return true; }; }\n        return new Promise(function (resolve, reject) {\n            var step = function () { return __awaiter(_this, void 0, void 0, function () {\n                var _a, nEpochs, currentEpoch, epochCompleted, shouldStop, isFinished;\n                return __generator(this, function (_b) {\n                    try {\n                        _a = this.optimizationState, nEpochs = _a.nEpochs, currentEpoch = _a.currentEpoch;\n                        this.embedding = this.optimizeLayoutStep(currentEpoch);\n                        epochCompleted = this.optimizationState.currentEpoch;\n                        shouldStop = epochCallback(epochCompleted) === false;\n                        isFinished = epochCompleted === nEpochs;\n                        if (!shouldStop && !isFinished) {\n                            setTimeout(function () { return step(); }, 0);\n                        }\n                        else {\n                            return [2, resolve(isFinished)];\n                        }\n                    }\n                    catch (err) {\n                        reject(err);\n                    }\n                    return [2];\n                });\n            }); };\n            setTimeout(function () { return step(); }, 0);\n        });\n    };\n    UMAP.prototype.optimizeLayout = function (epochCallback) {\n        if (epochCallback === void 0) { epochCallback = function () { return true; }; }\n        var isFinished = false;\n        var embedding = [];\n        while (!isFinished) {\n            var _a = this.optimizationState, nEpochs = _a.nEpochs, currentEpoch = _a.currentEpoch;\n            embedding = this.optimizeLayoutStep(currentEpoch);\n            var epochCompleted = this.optimizationState.currentEpoch;\n            var shouldStop = epochCallback(epochCompleted) === false;\n            isFinished = epochCompleted === nEpochs || shouldStop;\n        }\n        return embedding;\n    };\n    UMAP.prototype.getNEpochs = function () {\n        var graph = this.graph;\n        if (this.nEpochs > 0) {\n            return this.nEpochs;\n        }\n        var length = graph.nRows;\n        if (length <= 2500) {\n            return 500;\n        }\n        else if (length <= 5000) {\n            return 400;\n        }\n        else if (length <= 7500) {\n            return 300;\n        }\n        else {\n            return 200;\n        }\n    };\n    return UMAP;\n}());\nexports.UMAP = UMAP;\nfunction euclidean(x, y) {\n    var result = 0;\n    for (var i = 0; i < x.length; i++) {\n        result += Math.pow((x[i] - y[i]), 2);\n    }\n    return Math.sqrt(result);\n}\nexports.euclidean = euclidean;\nfunction cosine(x, y) {\n    var result = 0.0;\n    var normX = 0.0;\n    var normY = 0.0;\n    for (var i = 0; i < x.length; i++) {\n        result += x[i] * y[i];\n        normX += Math.pow(x[i], 2);\n        normY += Math.pow(y[i], 2);\n    }\n    if (normX === 0 && normY === 0) {\n        return 0;\n    }\n    else if (normX === 0 || normY === 0) {\n        return 1.0;\n    }\n    else {\n        return 1.0 - result / Math.sqrt(normX * normY);\n    }\n}\nexports.cosine = cosine;\nvar OptimizationState = (function () {\n    function OptimizationState() {\n        this.currentEpoch = 0;\n        this.headEmbedding = [];\n        this.tailEmbedding = [];\n        this.head = [];\n        this.tail = [];\n        this.epochsPerSample = [];\n        this.epochOfNextSample = [];\n        this.epochOfNextNegativeSample = [];\n        this.epochsPerNegativeSample = [];\n        this.moveOther = true;\n        this.initialAlpha = 1.0;\n        this.alpha = 1.0;\n        this.gamma = 1.0;\n        this.a = 1.5769434603113077;\n        this.b = 0.8950608779109733;\n        this.dim = 2;\n        this.nEpochs = 500;\n        this.nVertices = 0;\n    }\n    return OptimizationState;\n}());\nfunction clip(x, clipValue) {\n    if (x > clipValue)\n        return clipValue;\n    else if (x < -clipValue)\n        return -clipValue;\n    else\n        return x;\n}\nfunction rDist(x, y) {\n    var result = 0.0;\n    for (var i = 0; i < x.length; i++) {\n        result += Math.pow(x[i] - y[i], 2);\n    }\n    return result;\n}\nfunction findABParams(spread, minDist) {\n    var curve = function (_a) {\n        var _b = __read(_a, 2), a = _b[0], b = _b[1];\n        return function (x) {\n            return 1.0 / (1.0 + a * Math.pow(x, (2 * b)));\n        };\n    };\n    var xv = utils\n        .linear(0, spread * 3, 300)\n        .map(function (val) { return (val < minDist ? 1.0 : val); });\n    var yv = utils.zeros(xv.length).map(function (val, index) {\n        var gte = xv[index] >= minDist;\n        return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n    });\n    var initialValues = [0.5, 0.5];\n    var data = { x: xv, y: yv };\n    var options = {\n        damping: 1.5,\n        initialValues: initialValues,\n        gradientDifference: 10e-2,\n        maxIterations: 100,\n        errorTolerance: 10e-3,\n    };\n    var parameterValues = ml_levenberg_marquardt_1.default(data, curve, options).parameterValues;\n    var _a = __read(parameterValues, 2), a = _a[0], b = _a[1];\n    return { a: a, b: b };\n}\nexports.findABParams = findABParams;\nfunction fastIntersection(graph, target, unknownDist, farDist) {\n    if (unknownDist === void 0) { unknownDist = 1.0; }\n    if (farDist === void 0) { farDist = 5.0; }\n    return graph.map(function (value, row, col) {\n        if (target[row] === -1 || target[col] === -1) {\n            return value * Math.exp(-unknownDist);\n        }\n        else if (target[row] !== target[col]) {\n            return value * Math.exp(-farDist);\n        }\n        else {\n            return value;\n        }\n    });\n}\nexports.fastIntersection = fastIntersection;\nfunction resetLocalConnectivity(simplicialSet) {\n    simplicialSet = matrix.normalize(simplicialSet, \"max\");\n    var transpose = matrix.transpose(simplicialSet);\n    var prodMatrix = matrix.pairwiseMultiply(transpose, simplicialSet);\n    simplicialSet = matrix.add(simplicialSet, matrix.subtract(transpose, prodMatrix));\n    return matrix.eliminateZeros(simplicialSet);\n}\nexports.resetLocalConnectivity = resetLocalConnectivity;\nfunction initTransform(indices, weights, embedding) {\n    var result = utils\n        .zeros(indices.length)\n        .map(function (z) { return utils.zeros(embedding[0].length); });\n    for (var i = 0; i < indices.length; i++) {\n        for (var j = 0; j < indices[0].length; j++) {\n            for (var d = 0; d < embedding[0].length; d++) {\n                var a = indices[i][j];\n                result[i][d] += weights[i][j] * embedding[a][d];\n            }\n        }\n    }\n    return result;\n}\nexports.initTransform = initTransform;\n","const toString = Object.prototype.toString;\n\nexport default function isAnyArray(object) {\n  return toString.call(object).endsWith('Array]');\n}\n","/**\n * Calculate current error\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} parameters - Array of current parameter values\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {number}\n */\nexport default function errorCalculation(\n  data,\n  parameters,\n  parameterizedFunction,\n) {\n  let error = 0;\n  const func = parameterizedFunction(parameters);\n\n  for (let i = 0; i < data.x.length; i++) {\n    error += Math.abs(data.y[i] - func(data.x[i]));\n  }\n\n  return error;\n}\n","import { inverse, Matrix } from 'ml-matrix';\n\n/**\n * Difference of the matrix function over the parameters\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} paramFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Matrix}\n */\nfunction gradientFunction(\n  data,\n  evaluatedData,\n  params,\n  gradientDifference,\n  paramFunction,\n) {\n  const n = params.length;\n  const m = data.x.length;\n\n  let ans = new Array(n);\n\n  for (let param = 0; param < n; param++) {\n    ans[param] = new Array(m);\n    let auxParams = params.slice();\n    auxParams[param] += gradientDifference;\n    let funcParam = paramFunction(auxParams);\n\n    for (let point = 0; point < m; point++) {\n      ans[param][point] = evaluatedData[point] - funcParam(data.x[point]);\n    }\n  }\n  return new Matrix(ans);\n}\n\n/**\n * Matrix function over the samples\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @return {Matrix}\n */\nfunction matrixFunction(data, evaluatedData) {\n  const m = data.x.length;\n\n  let ans = new Array(m);\n\n  for (let point = 0; point < m; point++) {\n    ans[point] = [data.y[point] - evaluatedData[point]];\n  }\n\n  return new Matrix(ans);\n}\n\n/**\n * Iteration for Levenberg-Marquardt\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} damping - Levenberg-Marquardt parameter\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Array<number>}\n */\nexport default function step(\n  data,\n  params,\n  damping,\n  gradientDifference,\n  parameterizedFunction,\n) {\n  let value = damping * gradientDifference * gradientDifference;\n  let identity = Matrix.eye(params.length, params.length, value);\n\n  const func = parameterizedFunction(params);\n\n  let evaluatedData = new Float64Array(data.x.length);\n  for (let i = 0; i < data.x.length; i++) {\n    evaluatedData[i] = func(data.x[i]);\n  }\n\n  let gradientFunc = gradientFunction(\n    data,\n    evaluatedData,\n    params,\n    gradientDifference,\n    parameterizedFunction,\n  );\n  let matrixFunc = matrixFunction(data, evaluatedData);\n  let inverseMatrix = inverse(\n    identity.add(gradientFunc.mmul(gradientFunc.transpose())),\n  );\n\n  params = new Matrix([params]);\n  params = params.sub(\n    inverseMatrix\n      .mmul(gradientFunc)\n      .mmul(matrixFunc)\n      .mul(gradientDifference)\n      .transpose(),\n  );\n\n  return params.to1DArray();\n}\n","import isArray from 'is-any-array';\n\nimport errorCalculation from './errorCalculation';\nimport step from './step';\n\n/**\n * Curve fitting algorithm\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @param {object} [options] - Options object\n * @param {number} [options.damping] - Levenberg-Marquardt parameter\n * @param {number} [options.gradientDifference = 10e-2] - Adjustment for decrease the damping parameter\n * @param {Array<number>} [options.minValues] - Minimum allowed values for parameters\n * @param {Array<number>} [options.maxValues] - Maximum allowed values for parameters\n * @param {Array<number>} [options.initialValues] - Array of initial parameter values\n * @param {number} [options.maxIterations = 100] - Maximum of allowed iterations\n * @param {number} [options.errorTolerance = 10e-3] - Minimum uncertainty allowed for each point\n * @return {{parameterValues: Array<number>, parameterError: number, iterations: number}}\n */\nexport default function levenbergMarquardt(\n  data,\n  parameterizedFunction,\n  options = {},\n) {\n  let {\n    maxIterations = 100,\n    gradientDifference = 10e-2,\n    damping = 0,\n    errorTolerance = 10e-3,\n    minValues,\n    maxValues,\n    initialValues,\n  } = options;\n\n  if (damping <= 0) {\n    throw new Error('The damping option must be a positive number');\n  } else if (!data.x || !data.y) {\n    throw new Error('The data parameter must have x and y elements');\n  } else if (\n    !isArray(data.x) ||\n    data.x.length < 2 ||\n    !isArray(data.y) ||\n    data.y.length < 2\n  ) {\n    throw new Error(\n      'The data parameter elements must be an array with more than 2 points',\n    );\n  } else if (data.x.length !== data.y.length) {\n    throw new Error('The data parameter elements must have the same size');\n  }\n\n  let parameters =\n    initialValues || new Array(parameterizedFunction.length).fill(1);\n  let parLen = parameters.length;\n  maxValues = maxValues || new Array(parLen).fill(Number.MAX_SAFE_INTEGER);\n  minValues = minValues || new Array(parLen).fill(Number.MIN_SAFE_INTEGER);\n\n  if (maxValues.length !== minValues.length) {\n    throw new Error('minValues and maxValues must be the same size');\n  }\n\n  if (!isArray(parameters)) {\n    throw new Error('initialValues must be an array');\n  }\n\n  let error = errorCalculation(data, parameters, parameterizedFunction);\n\n  let converged = error <= errorTolerance;\n\n  let iteration;\n  for (iteration = 0; iteration < maxIterations && !converged; iteration++) {\n    parameters = step(\n      data,\n      parameters,\n      damping,\n      gradientDifference,\n      parameterizedFunction,\n    );\n\n    for (let k = 0; k < parLen; k++) {\n      parameters[k] = Math.min(\n        Math.max(minValues[k], parameters[k]),\n        maxValues[k],\n      );\n    }\n\n    error = errorCalculation(data, parameters, parameterizedFunction);\n    if (isNaN(error)) break;\n    converged = error <= errorTolerance;\n  }\n\n  return {\n    parameterValues: parameters,\n    parameterError: error,\n    iterations: iteration,\n  };\n}\n","\"use strict\";\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reshape2d = exports.rejectionSample = exports.max2d = exports.max = exports.mean = exports.sum = exports.linear = exports.ones = exports.zeros = exports.filled = exports.range = exports.empty = exports.norm = exports.tauRand = exports.tauRandInt = void 0;\nfunction tauRandInt(n, random) {\n    return Math.floor(random() * n);\n}\nexports.tauRandInt = tauRandInt;\nfunction tauRand(random) {\n    return random();\n}\nexports.tauRand = tauRand;\nfunction norm(vec) {\n    var e_1, _a;\n    var result = 0;\n    try {\n        for (var vec_1 = __values(vec), vec_1_1 = vec_1.next(); !vec_1_1.done; vec_1_1 = vec_1.next()) {\n            var item = vec_1_1.value;\n            result += Math.pow(item, 2);\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (vec_1_1 && !vec_1_1.done && (_a = vec_1.return)) _a.call(vec_1);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n    return Math.sqrt(result);\n}\nexports.norm = norm;\nfunction empty(n) {\n    var output = [];\n    for (var i = 0; i < n; i++) {\n        output.push(undefined);\n    }\n    return output;\n}\nexports.empty = empty;\nfunction range(n) {\n    return empty(n).map(function (_, i) { return i; });\n}\nexports.range = range;\nfunction filled(n, v) {\n    return empty(n).map(function () { return v; });\n}\nexports.filled = filled;\nfunction zeros(n) {\n    return filled(n, 0);\n}\nexports.zeros = zeros;\nfunction ones(n) {\n    return filled(n, 1);\n}\nexports.ones = ones;\nfunction linear(a, b, len) {\n    return empty(len).map(function (_, i) {\n        return a + i * ((b - a) / (len - 1));\n    });\n}\nexports.linear = linear;\nfunction sum(input) {\n    return input.reduce(function (sum, val) { return sum + val; });\n}\nexports.sum = sum;\nfunction mean(input) {\n    return sum(input) / input.length;\n}\nexports.mean = mean;\nfunction max(input) {\n    var max = 0;\n    for (var i = 0; i < input.length; i++) {\n        max = input[i] > max ? input[i] : max;\n    }\n    return max;\n}\nexports.max = max;\nfunction max2d(input) {\n    var max = 0;\n    for (var i = 0; i < input.length; i++) {\n        for (var j = 0; j < input[i].length; j++) {\n            max = input[i][j] > max ? input[i][j] : max;\n        }\n    }\n    return max;\n}\nexports.max2d = max2d;\nfunction rejectionSample(nSamples, poolSize, random) {\n    var result = zeros(nSamples);\n    for (var i = 0; i < nSamples; i++) {\n        var rejectSample = true;\n        while (rejectSample) {\n            var j = tauRandInt(poolSize, random);\n            var broken = false;\n            for (var k = 0; k < i; k++) {\n                if (j === result[k]) {\n                    broken = true;\n                    break;\n                }\n            }\n            if (!broken) {\n                rejectSample = false;\n            }\n            result[i] = j;\n        }\n    }\n    return result;\n}\nexports.rejectionSample = rejectionSample;\nfunction reshape2d(x, a, b) {\n    var rows = [];\n    var count = 0;\n    var index = 0;\n    if (x.length !== a * b) {\n        throw new Error('Array dimensions must match input length.');\n    }\n    for (var i = 0; i < a; i++) {\n        var col = [];\n        for (var j = 0; j < b; j++) {\n            col.push(x[index]);\n            index += 1;\n        }\n        rows.push(col);\n        count += 1;\n    }\n    return rows;\n}\nexports.reshape2d = reshape2d;\n"],"names":["_a","__createBinding","this","Object","create","o","m","k","k2","undefined","defineProperty","enumerable","get","__setModuleDefault","v","value","__importStar","mod","__esModule","result","hasOwnProperty","call","__read","n","Symbol","iterator","r","e","i","ar","next","done","push","error","__values","s","length","TypeError","exports","getCSR","normalize","eliminateZeros","multiplyScalar","maximum","subtract","add","pairwiseMultiply","identity","transpose","SparseMatrix","utils","rows","cols","values","dims","entries","Map","nRows","nCols","Error","row","col","checkDims","key","makeKey","set","prototype","has","defaultValue","getAll","ordered","rowColValues","forEach","sort","a","b","getDims","getRows","Array","from","_b","getCols","getValues","fn","map","vals","toArray","_this","output","empty","zeros","matrix","size","elementWise","x","y","scalar","zeroIndices","Set","removeByZeroIndex","_","index","nextValues","filter","nextRows","nextCols","normType","e_1","normFn","normFns","colsByRow","nextMatrix","_loop_1","norm","keys","_c","e_1_1","return","xs","max","sum","Math","pow","sqrt","op","visited","operate","nextValue","valuesA","rowsA","colsA","valuesB","rowsB","colsB","indices","indptr","currentRow","smallestFlagged","deheapSort","buildCandidates","uncheckedHeapPush","heapPush","rejectionSample","makeHeap","nPoints","makeArrays","fillValue","filled","heap","Infinity","weight","flag","floor","weights","isNew","iSwap","ic1","ic2","heapShape2","siftDown","heap1","heap2","ceiling","elt","leftChild","rightChild","swap","temp1","temp2","nSamples","poolSize","random","rejectSample","j","tauRandInt","broken","currentGraph","nVertices","nNeighbors","maxCandidates","candidateNeighbors","idx","isn","d","tauRand","indHeap","distHeap","indHeapIndex","distHeapIndex","ind","dist","minDist","resultIndex","initializeSearch","makeInitializedNNSearch","makeInitializations","makeNNDescent","tree","distanceFn","data","leafArray","nIters","delta","rho","rpTreeInit","c","p","q","cj","ck","initFromRandom","queryPoints","_heap","initFromTree","_tree","searchFlatTree","graph","initialization","tried","vertex","candidates","slice","candidates_1","candidates_1_1","candidate","forest","e_2","results","forest_1","forest_1_1","e_2_1","umap_1","UMAP","__spread","arguments","concat","makeLeafArray","makeForest","FlatTree","hyperplanes","offsets","children","makeEuclideanTree","leafSize","splitResults","dim","leftIndex","rightIndex","left","right","hyperplaneOffset","hyperplaneVector","nLeft","nRight","side","margin","indicesLeft","indicesRight","hyperplane","offset","euclideanRandomProjectionSplit","isLeaf","recursiveFlatten","nodeNum","leafNum","splice","apply","oldNodeNum","res","numNodes","numLeaves","selectSide","point","nTrees","range","makeTree","nNodes","nLeaves","flattenTree","rpForest","rpForest_1","rpForest_1_1","node","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","rejected","then","__generator","body","f","t","g","label","sent","trys","ops","verb","pop","__importDefault","initTransform","resetLocalConnectivity","fastIntersection","findABParams","cosine","euclidean","nnDescent","ml_levenberg_marquardt_1","SMOOTH_K_TOLERANCE","MIN_K_DIST_SCALE","params","learningRate","localConnectivity","nComponents","nEpochs","negativeSampleRate","repulsionStrength","setOpMixRatio","spread","transformQueueSize","targetMetric","targetWeight","targetNNeighbors","isInitialized","embedding","optimizationState","OptimizationState","setParam","fit","X","initializeFit","optimizeLayout","fitAsync","callback","optimizeLayoutAsync","setSupervisedProjection","Y","setPrecomputedKNN","knnIndices","knnDistances","getNEpochs","knnResults","nearestNeighbors","fuzzySimplicialSet","makeSearchFns","searchGraph","makeSearchGraph","processGraphForSupervisedProjection","initializeSimplicialSetEmbedding","head","tail","epochsPerSample","initializeOptimization","prepareForOptimizationLoop","search","knn","distances","neighbor","distance","transform","toTransform","rawData","min","init","adjustedLocalConnectivity","smoothKNNDistance","sigmas","rhos","computeMembershipStrengths","normed","csrMatrix","reshape2d","graphMax","reduce","val","makeEpochsPerSample","assignOptimizationStateParameters","headEmbedding","tailEmbedding","currentEpoch","farDist","categoricalSimplicialSetIntersection","optimizeLayoutStep","getEmbedding","metricNNDescent","round","log","log2","_d","_e","sparseMatrix","prodMatrix","simplicialSet","target","unknownDist","intersection","nIter","bandwidth","lo","hi","mid","ithDistances","nonZeroDists","interpolation","psum","exp","abs","meanIthDistances","mean","meanDistances","graphValues","entry","w","state","assign","moveOther","epochsPerNegativeSample","epochOfNextNegativeSample","epochOfNextSample","initialAlpha","alpha","gamma","current","other","distSquared","rDist","gradCoeff","gradD","clip","nNegSamples","k_1","other_1","distSquared_1","gradCoeff_1","epochCallback","epochCompleted","shouldStop","isFinished","setTimeout","err","normX","normY","clipValue","xv","linear","yv","parameterValues","default","damping","initialValues","gradientDifference","maxIterations","errorTolerance","z","toString","isAnyArray","object","endsWith","errorCalculation","parameters","parameterizedFunction","func","eye","evaluatedData","Float64Array","gradientFunc","paramFunction","ans","param","auxParams","funcParam","gradientFunction","matrixFunc","matrixFunction","inverseMatrix","mmul","sub","mul","to1DArray","levenbergMarquardt","options","minValues","maxValues","fill","parLen","Number","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","iteration","converged","isNaN","parameterError","iterations","input","max2d","ones","vec","vec_1","vec_1_1","item","len"],"sourceRoot":""}