{"version":3,"file":"druid.d.ts","sources":["types/metrics/bray_curtis.d.ts","types/metrics/canberra.d.ts","types/metrics/chebyshev.d.ts","types/metrics/cosine.d.ts","types/metrics/euclidean.d.ts","types/metrics/euclidean_squared.d.ts","types/metrics/goodman_kruskal.d.ts","types/metrics/hamming.d.ts","types/metrics/haversine.d.ts","types/metrics/jaccard.d.ts","types/metrics/manhattan.d.ts","types/metrics/sokal_michener.d.ts","types/metrics/wasserstein.d.ts","types/metrics/yule.d.ts","types/metrics/index.d.ts","types/matrix/distance_matrix.d.ts","types/matrix/k_nearest_neighbors.d.ts","types/matrix/linspace.d.ts","types/util/max.d.ts","types/util/min.d.ts","types/util/randomizer.d.ts","types/matrix/Matrix.d.ts","types/matrix/norm.d.ts","types/matrix/normalize.d.ts","types/clustering/Clustering.d.ts","types/clustering/CURE.d.ts","types/clustering/Hierarchical_Clustering.d.ts","types/clustering/KMeans.d.ts","types/clustering/KMedoids.d.ts","types/clustering/MeanShift.d.ts","types/clustering/OPTICS.d.ts","types/clustering/XMeans.d.ts","types/clustering/index.d.ts","types/datastructure/DisjointSet.d.ts","types/datastructure/Heap.d.ts","types/datastructure/index.d.ts","types/dimred/DR.d.ts","types/dimred/FASTMAP.d.ts","types/dimred/ISOMAP.d.ts","types/dimred/LDA.d.ts","types/dimred/LLE.d.ts","types/dimred/LSP.d.ts","types/dimred/LTSA.d.ts","types/dimred/MDS.d.ts","types/dimred/PCA.d.ts","types/dimred/SAMMON.d.ts","types/dimred/SMACOF.d.ts","types/dimred/SQDMDS.d.ts","types/dimred/TopoMap.d.ts","types/knn/KNN.d.ts","types/dimred/TriMap.d.ts","types/dimred/TSNE.d.ts","types/dimred/UMAP.d.ts","types/linear_algebra/inner_product.d.ts","types/linear_algebra/qr.d.ts","types/linear_algebra/qr_householder.d.ts","types/linear_algebra/simultaneous_poweriteration.d.ts","types/linear_algebra/index.d.ts","types/dimred/index.d.ts","types/knn/Annoy.d.ts","types/knn/BallTree.d.ts","types/knn/HNSW.d.ts","types/knn/KDTree.d.ts","types/knn/LSH.d.ts","types/knn/NaiveKNN.d.ts","types/knn/NNDescent.d.ts","types/knn/index.d.ts","types/numerical/kahan_sum.d.ts","types/numerical/neumair_sum.d.ts","types/optimization/powell.d.ts","types/index.d.ts"],"sourcesContent":["/**\n * Computes the Bray-Curtis distance between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The Bray-Curtis distance between `a` and `b`.\n * @see {@link https://en.wikipedia.org/wiki/Bray%E2%80%93Curtis_dissimilarity}\n */\nexport function bray_curtis(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=bray_curtis.d.ts.map","/**\n * Computes the canberra distance between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The canberra distance between `a` and `b`.\n * @see {@link https://en.wikipedia.org/wiki/Canberra_distance}\n */\nexport function canberra(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=canberra.d.ts.map","/**\n * Computes the chebyshev distance (L<sub>∞</sub>) between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The chebyshev distance between `a` and `b`.\n */\nexport function chebyshev(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=chebyshev.d.ts.map","/**\n * Computes the cosine distance (not similarity) between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The cosine distance between `a` and `b`.\n * @example\n * import { cosine } from \"@saehrimnir/druidjs\";\n * const a = [1, 2, 3];\n * const b = [4, 5, 6];\n * const distance = cosine(a, b); // 0.9746318461970762\n */\nexport function cosine(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=cosine.d.ts.map","/**\n * Computes the euclidean distance (`l_2`) between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The euclidean distance between `a` and `b`.\n */\nexport function euclidean(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=euclidean.d.ts.map","/**\n * Computes the squared euclidean distance (l_2^2) between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The squared euclidean distance between `a` and `b`.\n\n */\nexport function euclidean_squared(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=euclidean_squared.d.ts.map","/**\n * Computes the Goodman-Kruskal gamma coefficient for ordinal association.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a - First categorical/ordinal variable\n * @param {number[] | Float64Array} b - Second categorical/ordinal variable\n * @returns {number} The Goodman-Kruskal gamma coefficient between `a` and `b` (-1 to 1).\n * @see {@link https://en.wikipedia.org/wiki/Goodman_and_Kruskal%27s_gamma}\n */\nexport function goodman_kruskal(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=goodman_kruskal.d.ts.map","/**\n * Computes the hamming distance between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The hamming distance between `a` and `b`.\n */\nexport function hamming(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=hamming.d.ts.map","/**\n * Computes the Haversine distance between two points on a sphere of unit length 1. Multiply the result with the radius of the sphere. (For instance Earth's radius is 6371km)\n *\n * @category Metrics\n * @param {number[] | Float64Array} a - Point [lat1, lon1] in radians\n * @param {number[] | Float64Array} b - Point [lat2, lon2] in radians\n * @returns {number} The Haversine distance between `a` and `b`.\n * @see {@link https://en.wikipedia.org/wiki/Haversine_formula}\n */\nexport function haversine(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=haversine.d.ts.map","/**\n * Computes the jaccard distance between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The jaccard distance between `a` and `b`.\n */\nexport function jaccard(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=jaccard.d.ts.map","/**\n * Computes the manhattan distance (`l_1`) between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The manhattan distance between `a` and `b`.\n */\nexport function manhattan(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=manhattan.d.ts.map","/**\n * Computes the Sokal-Michener distance between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The Sokal-Michener distance between `a` and `b`.\n\n */\nexport function sokal_michener(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=sokal_michener.d.ts.map","/**\n * Computes the 1D Wasserstein distance (Earth Mover's Distance) between two distributions.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a - First distribution (histogram or probability mass)\n * @param {number[] | Float64Array} b - Second distribution (histogram or probability mass)\n * @returns {number} The Wasserstein/EMD distance between `a` and `b`.\n * @see {@link https://en.wikipedia.org/wiki/Wasserstein_metric}\n */\nexport function wasserstein(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=wasserstein.d.ts.map","/**\n * Computes the yule distance between `a` and `b`.\n *\n * @category Metrics\n * @param {number[] | Float64Array} a\n * @param {number[] | Float64Array} b\n * @returns {number} The yule distance between `a` and `b`.\n */\nexport function yule(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=yule.d.ts.map","export { bray_curtis } from \"./bray_curtis.js\";\nexport { canberra } from \"./canberra.js\";\nexport { chebyshev } from \"./chebyshev.js\";\nexport { cosine } from \"./cosine.js\";\nexport { euclidean } from \"./euclidean.js\";\nexport { euclidean_squared } from \"./euclidean_squared.js\";\nexport { goodman_kruskal } from \"./goodman_kruskal.js\";\nexport { hamming } from \"./hamming.js\";\nexport { haversine } from \"./haversine.js\";\nexport { jaccard } from \"./jaccard.js\";\nexport { manhattan } from \"./manhattan.js\";\nexport { sokal_michener } from \"./sokal_michener.js\";\nexport { wasserstein } from \"./wasserstein.js\";\nexport { yule } from \"./yule.js\";\nexport type Metric = (a: number[] | Float64Array, b: number[] | Float64Array) => number;\n//# sourceMappingURL=index.d.ts.map","/**\n * Computes the distance matrix of datamatrix `A`.\n *\n * @category Matrix\n * @param {Matrix | Float64Array[] | number[][]} A - Matrix.\n * @param {Metric} [metric=euclidean] - The diistance metric. Default is `euclidean`\n * @returns {Matrix} The distance matrix of `A`.\n */\nexport function distance_matrix(A: Matrix | Float64Array[] | number[][], metric?: Metric): Matrix;\nimport { Matrix } from \"./index.js\";\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=distance_matrix.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/**\n * Computes the k-nearest neighbors of each row of `A`.\n *\n * @category Matrix\n * @param {Matrix} A - Either the data matrix, or a distance matrix.\n * @param {number} k - The number of neighbors to compute.\n * @param {Metric | \"precomputed\"} [metric=euclidean] Default is `euclidean`\n * @returns {{ i: number; j: number; distance: number }[][]} The kNN graph.\n */\nexport function k_nearest_neighbors(A: Matrix, k: number, metric?: Metric | \"precomputed\"): {\n    i: number;\n    j: number;\n    distance: number;\n}[][];\nimport { Matrix } from \"../matrix/index.js\";\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=k_nearest_neighbors.d.ts.map","/**\n * Creates an Array containing `number` numbers from `start` to `end`. If `number = null`.\n *\n * @category Matrix\n * @param {number} start - Start value.\n * @param {number} end - End value.\n * @param {number} [number] - Number of number between `start` and `end`.\n * @returns {number[]} An array with `number` entries, beginning at `start` ending at `end`.\n */\nexport function linspace(start: number, end: number, number?: number): number[];\n//# sourceMappingURL=linspace.d.ts.map","/**\n * Returns maximum in Array `values`.\n *\n * @category Utils\n * @param {Iterable<number | null>} values\n * @returns {number}\n */\nexport function max(values: Iterable<number | null>): number;\n//# sourceMappingURL=max.d.ts.map","/**\n * Returns maximum in Array `values`.\n *\n * @category Utils\n * @param {Iterable<number | null>} values\n * @returns {number}\n */\nexport function min(values: Iterable<number | null>): number;\n//# sourceMappingURL=min.d.ts.map","/**\n * @category Utils\n * @class\n */\nexport class Randomizer {\n    /**\n     * @template T Returns samples from an input Matrix or Array.\n     * @param {T[]} A - The input Matrix or Array.\n     * @param {number} n - The number of samples.\n     * @param {number} seed - The seed for the random number generator.\n     * @returns {T[]} - A random selection form `A` of `n` samples.\n     */\n    static choice<T>(A: T[], n: number, seed?: number): T[];\n    /**\n     * Mersenne Twister random number generator.\n     *\n     * @param {number} [_seed=new Date().getTime()] - The seed for the random number generator. If `_seed == null` then\n     *   the actual time gets used as seed. Default is `new Date().getTime()`\n     * @see https://github.com/bmurray7/mersenne-twister-examples/blob/master/javascript-mersenne-twister.js\n     */\n    constructor(_seed?: number);\n    _N: number;\n    _M: number;\n    _MATRIX_A: number;\n    _UPPER_MASK: number;\n    _LOWER_MASK: number;\n    /** @type {number[]} */\n    _mt: number[];\n    /** @type {number} */\n    _mti: number;\n    /** @type {number} */\n    _seed: number;\n    /** @type {number} seed */\n    set seed(_seed: number);\n    /**\n     * Returns the seed of the random number generator.\n     *\n     * @returns {number} - The seed.\n     */\n    get seed(): number;\n    /**\n     * Returns a float between 0 and 1.\n     *\n     * @returns {number} - A random number between [0, 1]\n     */\n    get random(): number;\n    /**\n     * Returns an integer between 0 and MAX_INTEGER.\n     *\n     * @returns {number} - A random integer.\n     */\n    get random_int(): number;\n    gauss_random(): number;\n    _val: number | null | undefined;\n    /**\n     * @template T Returns samples from an input Matrix or Array.\n     * @param {T[]} A - The input Matrix or Array.\n     * @param {number} n - The number of samples.\n     * @returns {T[]} A random selection form `A` of `n` samples.\n     */\n    choice<T>(A: T[], n: number): T[];\n}\n//# sourceMappingURL=randomizer.d.ts.map","/** @typedef {(i: number, j: number) => number} Accessor */\n/**\n * @class\n * @category Matrix\n */\nexport class Matrix {\n    /**\n     * Creates a Matrix out of `A`.\n     * @param {Matrix | Float64Array[] | number[][]} A - The matrix, array, or number, which should converted to a Matrix.\n     * @returns {Matrix}\n     * @example\n     * let A = Matrix.from([ [1, 0], [0, 1], ]); //creates a two by two identity matrix.\n     */\n    static from(A: Matrix | Float64Array[] | number[][]): Matrix;\n    /**\n     * Creates a Matrix with the diagonal being the values of `v`.\n     *\n     * @example let S = Matrix.from_diag([1, 2, 3]); // creates [[1, 0, 0], [0, 2, 0], [0, 0, 3]]\n     *\n     * @param {number[] | Float64Array} v\n     * @returns {Matrix}\n     */\n    static from_diag(v: number[] | Float64Array): Matrix;\n    /**\n     * Creates a Matrix with the diagonal being the values of `v`.\n     *\n     * @example let S = Matrix.from_diag([1, 2, 3]); // creates [[1, 0, 0], [0, 2, 0], [0, 0, 3]]\n     *\n     * @param {number[] | Float64Array} v\n     * @param {\"col\" | \"row\"} type\n     * @returns {Matrix}\n     */\n    static from_vector(v: number[] | Float64Array, type: \"col\" | \"row\"): Matrix;\n    /**\n     * Solves the equation `Ax = b` using the conjugate gradient method. Returns the result `x`.\n     *\n     * @param {Matrix} A - Matrix\n     * @param {Matrix} b - Matrix\n     * @param {Randomizer | null} [randomizer]\n     * @param {number} [tol=1e-3] Default is `1e-3`\n     * @returns {Matrix}\n     */\n    static solve_CG(A: Matrix, b: Matrix, randomizer?: Randomizer | null, tol?: number): Matrix;\n    /**\n     * Solves the equation `Ax = b`. Returns the result `x`.\n     *\n     * @param {Matrix | { L: Matrix; U: Matrix }} A - Matrix or LU Decomposition\n     * @param {Matrix} b - Matrix\n     * @returns {Matrix}\n     */\n    static solve(A: Matrix | {\n        L: Matrix;\n        U: Matrix;\n    }, b: Matrix): Matrix;\n    /**\n     * `LU` decomposition of the Matrix `A`. Creates two matrices, so that the dot product `LU` equals `A`.\n     *\n     * @param {Matrix} A\n     * @returns {{ L: Matrix; U: Matrix }} The left triangle matrix `L` and the upper triangle matrix `U`.\n     */\n    static LU(A: Matrix): {\n        L: Matrix;\n        U: Matrix;\n    };\n    /**\n     * Computes the determinante of `A`, by using the `LU` decomposition of `A`.\n     *\n     * @param {Matrix} A\n     * @returns {number} The determinate of the Matrix `A`.\n     */\n    static det(A: Matrix): number;\n    /**\n     * Computes the `k` components of the SVD decomposition of the matrix `M`.\n     *\n     * @param {Matrix} M\n     * @param {number} [k=2] Default is `2`\n     * @returns {{ U: Float64Array[]; Sigma: Float64Array; V: Float64Array[] }}\n     */\n    static SVD(M: Matrix, k?: number): {\n        U: Float64Array[];\n        Sigma: Float64Array;\n        V: Float64Array[];\n    };\n    /**\n     * @param {unknown} A\n     * @returns {A is unknown[]|number[]|Float64Array|Float32Array}\n     */\n    static isArray(A: unknown): A is unknown[] | number[] | Float64Array | Float32Array;\n    /**\n     * @param {any[]} A\n     * @returns {A is number[][]|Float64Array[]}\n     */\n    static is2dArray(A: any[]): A is number[][] | Float64Array[];\n    /**\n     * Creates a new Matrix. Entries are stored in a Float64Array.\n     *\n     * @example let A = new Matrix(10, 10, () => Math.random()); //creates a 10 times 10 random matrix. let B = new\n     * Matrix(3, 3, \"I\"); // creates a 3 times 3 identity matrix.\n     *\n     * @param {number} rows - The amount of rows of the matrix.\n     * @param {number} cols - The amount of columns of the matrix.\n     * @param {Accessor | string | number} value - Can be a function with row and col as parameters, a number, or\n     *   \"zeros\", \"identity\" or \"I\", or \"center\".\n     *\n     *   - **function**: for each entry the function gets called with the parameters for the actual row and column.\n     *   - **string**: allowed are\n     *\n     *       - \"zero\", creates a zero matrix.\n     *       - \"identity\" or \"I\", creates an identity matrix.\n     *       - \"center\", creates an center matrix.\n     *   - **number**: create a matrix filled with the given value.\n     */\n    constructor(rows: number, cols: number, value?: Accessor | string | number);\n    /** @type {number} */ _rows: number;\n    /** @type {number} */ _cols: number;\n    /** @type {Float64Array} */ _data: Float64Array;\n    /**\n     * Returns the `row`<sup>th</sup> row from the Matrix.\n     *\n     * @param {number} row\n     * @returns {Float64Array}\n     */\n    row(row: number): Float64Array;\n    /**\n     * Returns an generator yielding each row of the Matrix.\n     *\n     * @yields {Float64Array}\n     */\n    iterate_rows(): Generator<Float64Array<ArrayBufferLike>, void, unknown>;\n    /**\n     * Sets the entries of `row`<sup>th</sup> row from the Matrix to the entries from `values`.\n     *\n     * @param {number} row\n     * @param {number[]} values\n     * @returns {Matrix}\n     */\n    set_row(row: number, values: number[]): Matrix;\n    /**\n     * Swaps the rows `row1` and `row2` of the Matrix.\n     *\n     * @param {number} row1\n     * @param {number} row2\n     * @returns {Matrix}\n     */\n    swap_rows(row1: number, row2: number): Matrix;\n    /**\n     * Returns the col<sup>th</sup> column from the Matrix.\n     *\n     * @param {number} col\n     * @returns {Float64Array}\n     */\n    col(col: number): Float64Array;\n    /**\n     * Returns the `col`<sup>th</sup> entry from the `row`<sup>th</sup> row of the Matrix.\n     *\n     * @param {number} row\n     * @param {number} col\n     * @returns {number}\n     */\n    entry(row: number, col: number): number;\n    /**\n     * Sets the {@link col}<sup>th</sup> entry from the {@link row}<sup>th</sup> row of the Matrix to the given\n     * {@link value}.\n     *\n     * @param {number} row\n     * @param {number} col\n     * @param {number} value\n     * @returns {Matrix}\n     */\n    set_entry(row: number, col: number, value: number): Matrix;\n    /**\n     * Adds a given {@link value} to the {@link col}<sup>th</sup> entry from the {@link row}<sup>th</sup> row of the\n     * Matrix.\n     *\n     * @param {number} row\n     * @param {number} col\n     * @param {number} value\n     * @returns {Matrix}\n     */\n    add_entry(row: number, col: number, value: number): Matrix;\n    /**\n     * Subtracts a given {@link value} from the {@link col}<sup>th</sup> entry from the {@link row}<sup>th</sup> row of the\n     * Matrix.\n     *\n     * @param {number} row\n     * @param {number} col\n     * @param {number} value\n     * @returns {Matrix}\n     */\n    sub_entry(row: number, col: number, value: number): Matrix;\n    /**\n     * Returns a new transposed Matrix.\n     *\n     * @returns {Matrix}\n     */\n    transpose(): Matrix;\n    /**\n     * Returns a new transposed Matrix. Short-form of `transpose`.\n     *\n     * @returns {Matrix}\n     */\n    get T(): Matrix;\n    /**\n     * Returns the inverse of the Matrix.\n     *\n     * @returns {Matrix}\n     */\n    inverse(): Matrix;\n    /**\n     * Returns the dot product. If `B` is an Array or Float64Array then an Array gets returned. If `B` is a Matrix then\n     * a Matrix gets returned.\n     *\n     * @param {Matrix | number[] | Float64Array} B The right side\n     * @returns {Matrix}\n     */\n    dot(B: Matrix | number[] | Float64Array): Matrix;\n    /**\n     * Transposes the current matrix and returns the dot product with `B`. If `B` is an Array or Float64Array then an\n     * Array gets returned. If `B` is a Matrix then a Matrix gets returned.\n     *\n     * @param {Matrix | number[] | Float64Array} B The right side\n     * @returns {Matrix}\n     */\n    transDot(B: Matrix | number[] | Float64Array): Matrix;\n    /**\n     * Returns the dot product with the transposed version of `B`. If `B` is an Array or Float64Array then an Array gets\n     * returned. If `B` is a Matrix then a Matrix gets returned.\n     *\n     * @param {Matrix | number[] | Float64Array} B The right side\n     * @returns {Matrix}\n     */\n    dotTrans(B: Matrix | number[] | Float64Array): Matrix;\n    /**\n     * Computes the outer product from `this` and `B`.\n     *\n     * @param {Matrix} B\n     * @returns {Matrix}\n     */\n    outer(B: Matrix): Matrix;\n    /**\n     * Appends matrix `B` to the matrix.\n     *\n     * @example let A = Matrix.from([ [1, 1], [1, 1], ]); // 2 by 2 matrix filled with ones. let B = Matrix.from([ [2,\n     * 2], [2, 2], ]); // 2 by 2 matrix filled with twos.\n     *\n     *     A.concat(B, \"horizontal\"); // 2 by 4 matrix. [[1, 1, 2, 2], [1, 1, 2, 2]]\n     *     A.concat(B, \"vertical\"); // 4 by 2 matrix. [[1, 1], [1, 1], [2, 2], [2, 2]]\n     *     A.concat(B, \"diag\"); // 4 by 4 matrix. [[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2], [0, 0, 2, 2]]\n     *\n     * @param {Matrix} B - Matrix to append.\n     * @param {\"horizontal\" | \"vertical\" | \"diag\"} [type=\"horizontal\"] - Type of concatenation. Default is\n     *   `\"horizontal\"`\n     * @returns {Matrix}\n     */\n    concat(B: Matrix, type?: \"horizontal\" | \"vertical\" | \"diag\"): Matrix;\n    /**\n     * Writes the entries of B in A at an offset position given by `offset_row` and `offset_col`.\n     *\n     * @param {number} offset_row\n     * @param {number} offset_col\n     * @param {Matrix} B\n     * @returns {Matrix}\n     */\n    set_block(offset_row: number, offset_col: number, B: Matrix): Matrix;\n    /**\n     * Extracts the entries from the `start_row`<sup>th</sup> row to the `end_row`<sup>th</sup> row, the\n     * `start_col`<sup>th</sup> column to the `end_col`<sup>th</sup> column of the matrix. If `end_row` or `end_col` is\n     * empty, the respective value is set to `this.rows` or `this.cols`.\n     *\n     * @example let A = Matrix.from([ [1, 2, 3], [4, 5, 6], [7, 8, 9], ]); // a 3 by 3 matrix.\n     *\n     *     A.get_block(1, 1); // [[5, 6], [8, 9]]\n     *     A.get_block(0, 0, 1, 1); // [[1]]\n     *     A.get_block(1, 1, 2, 2); // [[5]]\n     *     A.get_block(0, 0, 2, 2); // [[1, 2], [4, 5]]\n     *\n     * @param {number} start_row\n     * @param {number} start_col\n     * @param {number | null} [end_row]\n     * @param {number | null} [end_col]\n     * @returns {Matrix} Returns a `end_row` - `start_row` times `end_col` - `start_col` matrix, with respective entries\n     *   from the matrix.\n     */\n    get_block(start_row: number, start_col: number, end_row?: number | null, end_col?: number | null): Matrix;\n    /**\n     * Returns a new array gathering entries defined by the indices given by argument.\n     *\n     * @param {number[]} row_indices - Array consists of indices of rows for gathering entries of this matrix\n     * @param {number[]} col_indices - Array consists of indices of cols for gathering entries of this matrix\n     * @returns {Matrix}\n     */\n    gather(row_indices: number[], col_indices: number[]): Matrix;\n    /**\n     * Applies a function to each entry of the matrix.\n     *\n     * @private\n     * @param {(d: number, v: number) => number} f Function takes 2 parameters, the value of the actual entry and a\n     *   value given by the function `v`. The result of `f` gets writen to the Matrix.\n     * @param {Accessor} v Function takes 2 parameters for `row` and `col`, and returns a value witch should be applied\n     *   to the `col`<sup>th</sup> entry of the `row`<sup>th</sup> row of the matrix.\n     * @returns {Matrix}\n     */\n    private _apply_array;\n    /**\n     * @param {number[] | Float64Array} values\n     * @param {(d: number, v: number) => number} f\n     * @returns {Matrix}\n     */\n    _apply_rowwise_array(values: number[] | Float64Array, f: (d: number, v: number) => number): Matrix;\n    /**\n     * @param {number[] | Float64Array} values\n     * @param {(d: number, v: number) => number} f\n     * @returns {Matrix}\n     */\n    _apply_colwise_array(values: number[] | Float64Array, f: (d: number, v: number) => number): Matrix;\n    /**\n     * @param {Matrix | number[] | Float64Array | number} value\n     * @param {(d: number, v: number) => number} f\n     * @returns {Matrix}\n     */\n    _apply(value: Matrix | number[] | Float64Array | number, f: (d: number, v: number) => number): Matrix;\n    /**\n     * Clones the Matrix.\n     *\n     * @returns {Matrix}\n     */\n    clone(): Matrix;\n    /**\n     * Entrywise multiplication with `value`.\n     *\n     * @example let A = Matrix.from([ [1, 2], [3, 4], ]); // a 2 by 2 matrix. let B = A.clone(); // B == A;\n     *\n     *     A.mult(2); // [[2, 4], [6, 8]];\n     *     A.mult(B); // [[1, 4], [9, 16]];\n     *\n     * @param {Matrix | Float64Array | number[] | number} value\n     * @param {Object} [options]\n     * @param {boolean} [options.inline=false] - If true, applies multiplication to the element, otherwise it creates\n     *   first a copy and applies the multiplication on the copy. Default is `false`\n     * @returns {Matrix}\n     */\n    mult(value: Matrix | Float64Array | number[] | number, { inline }?: {\n        inline?: boolean | undefined;\n    }): Matrix;\n    /**\n     * Entrywise division with `value`.\n     *\n     * @example let A = Matrix.from([ [1, 2], [3, 4], ]); // a 2 by 2 matrix. let B = A.clone(); // B == A;\n     *\n     *     A.divide(2); // [[0.5, 1], [1.5, 2]];\n     *     A.divide(B); // [[1, 1], [1, 1]];\n     *\n     * @param {Matrix | Float64Array | number[] | number} value\n     * @param {Object} [options]\n     * @param {Boolean} [options.inline=false] - If true, applies division to the element, otherwise it creates first a\n     *   copy and applies the division on the copy. Default is `false`\n     * @returns {Matrix}\n     */\n    divide(value: Matrix | Float64Array | number[] | number, { inline }?: {\n        inline?: boolean | undefined;\n    }): Matrix;\n    /**\n     * Entrywise addition with `value`.\n     *\n     * @example let A = Matrix.from([ [1, 2], [3, 4], ]); // a 2 by 2 matrix. let B = A.clone(); // B == A;\n     *\n     *     A.add(2); // [[3, 4], [5, 6]];\n     *     A.add(B); // [[2, 4], [6, 8]];\n     *\n     * @param {Matrix | Float64Array | number[] | number} value\n     * @param {Object} [options]\n     * @param {boolean} [options.inline=false] - If true, applies addition to the element, otherwise it creates first a\n     *   copy and applies the addition on the copy. Default is `false`\n     * @returns {Matrix}\n     */\n    add(value: Matrix | Float64Array | number[] | number, { inline }?: {\n        inline?: boolean | undefined;\n    }): Matrix;\n    /**\n     * Entrywise subtraction with `value`.\n     *\n     * @example let A = Matrix.from([ [1, 2], [3, 4], ]); // a 2 by 2 matrix. let B = A.clone(); // B == A;\n     *\n     *     A.sub(2); // [[-1, 0], [1, 2]];\n     *     A.sub(B); // [[0, 0], [0, 0]];\n     *\n     * @param {Matrix | Float64Array | number[] | number} value\n     * @param {Object} [options]\n     * @param {boolean} [options.inline=false] - If true, applies subtraction to the element, otherwise it creates first\n     *   a copy and applies the subtraction on the copy. Default is `false`\n     * @returns {Matrix}\n     */\n    sub(value: Matrix | Float64Array | number[] | number, { inline }?: {\n        inline?: boolean | undefined;\n    }): Matrix;\n    /**\n     * Returns the matrix in the given shape with the given function which returns values for the entries of the matrix.\n     *\n     * @param {[number, number, Accessor]} parameter - Takes an Array in the form [rows, cols, value], where rows and\n     *   cols are the number of rows and columns of the matrix, and value is a function which takes two parameters (row\n     *   and col) which has to return a value for the colth entry of the rowth row.\n     * @returns {Matrix}\n     */\n    set shape([rows, cols, value]: [number, number, Accessor]);\n    /**\n     * Returns the number of rows and columns of the Matrix.\n     *\n     * @returns {number[]} An Array in the form [rows, columns].\n     */\n    get shape(): number[];\n    /**\n     * Returns the Matrix as a Array of Float64Arrays.\n     *\n     * @returns {Float64Array[]}\n     */\n    to2dArray(): Float64Array[];\n    /**\n     * Returns the Matrix as a Array of Arrays.\n     *\n     * @returns {number[][]}\n     */\n    asArray(): number[][];\n    /**\n     * Returns the diagonal of the Matrix.\n     *\n     * @returns {Float64Array}\n     */\n    diag(): Float64Array;\n    /**\n     * Returns the mean of all entries of the Matrix.\n     *\n     * @returns {number}\n     */\n    mean(): number;\n    /**\n     * Returns the sum oof all entries of the Matrix.\n     *\n     * @returns {number}\n     */\n    sum(): number;\n    /**\n     * Returns the entries of the Matrix.\n     *\n     * @returns {Float64Array}\n     */\n    get values(): Float64Array;\n    /**\n     * Returns the mean of each row of the matrix.\n     *\n     * @returns {Float64Array}\n     */\n    meanRows(): Float64Array;\n    /**\n     * Returns the mean of each column of the matrix.\n     *\n     * @returns {Float64Array}\n     */\n    meanCols(): Float64Array;\n    /**\n     * Makes a `Matrix` object an iterable object.\n     *\n     * @yields {Float64Array}\n     */\n    [Symbol.iterator](): Generator<Float64Array<ArrayBufferLike>, void, unknown>;\n}\nexport type Accessor = (i: number, j: number) => number;\nimport { Randomizer } from \"../util/index.js\";\n//# sourceMappingURL=Matrix.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/**\n * Computes the norm of a vector, by computing its distance to **0**.\n *\n * @category Matrix\n * @param {Matrix | number[] | Float64Array} v - Vector.\n * @param {Metric} [metric=euclidean] - Which metric should be used to compute the norm. Default is `euclidean`\n * @returns {number} - The norm of `v`.\n */\nexport function norm(v: Matrix | number[] | Float64Array, metric?: Metric): number;\nimport { Matrix } from \"../matrix/index.js\";\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=norm.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/**\n * Normalizes Vector `v`.\n *\n * @category Matrix\n * @param {number[] | Float64Array} v - Vector\n * @param {Metric} metric\n * @returns {number[] | Float64Array} - The normalized vector with length 1.\n */\nexport function normalize(v: number[] | Float64Array, metric?: Metric): number[] | Float64Array;\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=normalize.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/**\n * Base class for all clustering algorithms.\n * @template Para\n */\nexport class Clustering<Para> {\n    /**\n     * Compute the respective Clustering with given parameters\n     * @param {InputType} points\n     * @param {Para} parameters\n     */\n    constructor(points: InputType, parameters: Para);\n    /** @type {InputType} */\n    _points: InputType;\n    /** @type {Para} */\n    _parameters: Para;\n    /** @type {Matrix} */\n    _matrix: Matrix;\n    /** @type {number} */\n    _N: number;\n    /** @type {number} */\n    _D: number;\n    /**\n     * @abstract\n     * @param {...unknown} args\n     * @returns {number[][]} An array with the indices of the clusters.\n     */\n    get_clusters(...args: unknown[]): number[][];\n    /**\n     * @abstract\n     * @param {...unknown} args\n     * @returns {number[]} An array with the clusters id's for each point.\n     */\n    get_cluster_list(...args: unknown[]): number[];\n}\nimport type { InputType } from \"../index.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=Clustering.d.ts.map","/** @import { InputType } from \"../index.js\" */\n/** @import { ParametersCURE } from \"./index.js\" */\n/**\n * CURE (Clustering Using REpresentatives)\n *\n * An efficient clustering algorithm for large databases that is robust to outliers\n * and identifies clusters with non-spherical shapes and wide variances in size.\n *\n * @class\n * @extends Clustering<ParametersCURE>\n * @category Clustering\n */\nexport class CURE extends Clustering<ParametersCURE> {\n    /**\n     * @param {InputType} points\n     * @param {Partial<ParametersCURE>} parameters\n     */\n    constructor(points: InputType, parameters?: Partial<ParametersCURE>);\n    /** @type {number} */\n    _K: number;\n    /** @type {number} */\n    _num_representatives: number;\n    /** @type {number} */\n    _shrink_factor: number;\n    /**\n     * @private\n     * @type {CURECluster[]}\n     */\n    private _clusters;\n    /** @type {number[]} */\n    _cluster_ids: number[];\n    /**\n     * Initialize each point as its own cluster\n     * @private\n     */\n    private _initialize_clusters;\n    /**\n     * Compute distance between two clusters using representative points\n     * @private\n     * @param {CURECluster} cluster1\n     * @param {CURECluster} cluster2\n     * @returns {number}\n     */\n    private _cluster_distance;\n    /**\n     * Find the closest pair of clusters\n     * @private\n     * @returns {[number, number, number]} [index1, index2, distance]\n     */\n    private _find_closest_clusters;\n    /**\n     * Merge two clusters\n     * @private\n     * @param {CURECluster} cluster1\n     * @param {CURECluster} cluster2\n     * @returns {CURECluster}\n     */\n    private _merge_clusters;\n    /**\n     * Run CURE clustering algorithm\n     * @private\n     */\n    private _cure;\n    /**\n     * Build the cluster list (point -> cluster assignment)\n     * @private\n     */\n    private _build_cluster_ids;\n    /**\n     * @returns {number[][]}\n     */\n    get_clusters(): number[][];\n    /**\n     * @returns {number[]}\n     */\n    get_cluster_list(): number[];\n}\nimport type { ParametersCURE } from \"./index.js\";\nimport { Clustering } from \"./Clustering.js\";\nimport type { InputType } from \"../index.js\";\n//# sourceMappingURL=CURE.d.ts.map","/** @import { InputType } from \"../index.js\" */\n/** @import { ParametersHierarchicalClustering } from \"./index.js\" */\n/**\n * Hierarchical Clustering\n *\n * A bottom-up approach (agglomerative) to clustering that builds a tree of clusters (dendrogram).\n * Supports different linkage criteria: single, complete, and average.\n *\n * @class\n * @extends Clustering<ParametersHierarchicalClustering>\n * @category Clustering\n */\nexport class HierarchicalClustering extends Clustering<ParametersHierarchicalClustering> {\n    /**\n     * @param {InputType} points - Data or distance matrix if metric is 'precomputed'\n     * @param {Partial<ParametersHierarchicalClustering>} parameters\n     */\n    constructor(points: InputType, parameters?: Partial<ParametersHierarchicalClustering>);\n    /** @type {Cluster | null} */\n    root: Cluster | null;\n    _id: number;\n    _d_min: Float64Array<ArrayBuffer>;\n    _distance_matrix: Matrix;\n    _clusters: any[];\n    _c_size: Uint16Array<ArrayBuffer>;\n    /**\n     * @param {number} value - Value where to cut the tree.\n     * @param {\"distance\" | \"depth\"} [type=\"distance\"] - Type of value. Default is `\"distance\"`\n     * @returns {Cluster[][]} - Array of clusters with the indices of the rows in given points.\n     */\n    get_clusters_raw(value: number, type?: \"distance\" | \"depth\"): Cluster[][];\n    /**\n     * @param {number} value - Value where to cut the tree.\n     * @param {\"distance\" | \"depth\"} [type=\"distance\"] - Type of value. Default is `\"distance\"`\n     * @returns {number[][]} - Array of clusters with the indices of the rows in given points.\n     */\n    get_clusters(value: number, type?: \"distance\" | \"depth\"): number[][];\n    /**\n     * @param {number} value - Value where to cut the tree.\n     * @param {\"distance\" | \"depth\"} [type=\"distance\"] - Type of value. Default is `\"distance\"`\n     * @returns {number[]} - Array of clusters with the indices of the rows in given points.\n     */\n    get_cluster_list(value: number, type?: \"distance\" | \"depth\"): number[];\n    /**\n     * @private\n     * @param {Cluster} node\n     * @param {(d: {dist: number, depth: number}) => number} f\n     * @param {number} value\n     * @param {Cluster[][]} result\n     */\n    private _traverse;\n}\nimport type { ParametersHierarchicalClustering } from \"./index.js\";\nimport { Clustering } from \"./Clustering.js\";\n/** @private */\ndeclare class Cluster {\n    /**\n     *\n     * @param {number} id\n     * @param {Cluster?} left\n     * @param {Cluster?} right\n     * @param {number} dist\n     * @param {Float64Array?} centroid\n     * @param {number} index\n     * @param {number} [size]\n     * @param {number} [depth]\n     */\n    constructor(id: number, left: Cluster | null, right: Cluster | null, dist: number, centroid: Float64Array | null, index: number, size?: number, depth?: number);\n    /**@type {number} */\n    size: number;\n    /**@type {number} */\n    depth: number;\n    /**@type {Cluster | null} */\n    parent: Cluster | null;\n    id: number;\n    left: Cluster | null;\n    right: Cluster | null;\n    dist: number;\n    index: number;\n    centroid: Float64Array<ArrayBufferLike>;\n    /**\n     *\n     * @param {Cluster} left\n     * @param {Cluster} right\n     * @returns {Float64Array}\n     */\n    _calculate_centroid(left: Cluster, right: Cluster): Float64Array;\n    get isLeaf(): boolean;\n    /**\n     *\n     * @returns {Cluster[]}\n     */\n    leaves(): Cluster[];\n    /**\n     *\n     * @returns {Cluster[]}\n     */\n    descendants(): Cluster[];\n}\nimport { Matrix } from \"../matrix/index.js\";\nimport type { InputType } from \"../index.js\";\nexport {};\n//# sourceMappingURL=Hierarchical_Clustering.d.ts.map","/** @import { InputType } from \"../index.js\" */\n/** @import { ParametersKMeans } from \"./index.js\" */\n/**\n * K-Means Clustering\n *\n * A popular clustering algorithm that partitions data into K clusters where each point\n * belongs to the cluster with the nearest mean (centroid).\n *\n * @class\n * @extends Clustering<ParametersKMeans>\n * @category Clustering\n * @see {@link KMedoids} for a more robust alternative\n *\n * @example\n * import * as druid from \"@saehrimnir/druidjs\";\n *\n * const points = [[1, 1], [1.5, 1.5], [5, 5], [5.5, 5.5]];\n * const kmeans = new druid.KMeans(points, { K: 2 });\n *\n * const clusters = kmeans.get_cluster_list(); // [0, 0, 1, 1]\n * const centroids = kmeans.centroids; // center points\n */\nexport class KMeans extends Clustering<ParametersKMeans> {\n    /**\n     * @param {InputType} points\n     * @param {Partial<ParametersKMeans>} parameters\n     */\n    constructor(points: InputType, parameters?: Partial<ParametersKMeans>);\n    _K: number;\n    _randomizer: Randomizer;\n    /** @type {number[]} */\n    _clusters: number[];\n    _cluster_centroids: Float64Array<ArrayBufferLike>[];\n    /** @returns {number} The number of clusters */\n    get k(): number;\n    /** @returns {Float64Array[]} The cluster centroids */\n    get centroids(): Float64Array[];\n    /** @returns {number[]} The cluster list */\n    get_cluster_list(): number[];\n    /** @returns {number[][]} An Array of clusters with the indices of the points. */\n    get_clusters(): number[][];\n    /**\n     * @private\n     * @param {number[]} point_indices\n     * @param {number[]} candidates\n     * @returns {number}\n     */\n    private _furthest_point;\n    /**\n     * @private\n     * @param {number} K\n     * @returns {Float64Array[]}\n     */\n    private _get_random_centroids;\n    /**\n     * @private\n     * @param {Float64Array[]} cluster_centroids\n     * @returns {{ clusters_changed: boolean; cluster_centroids: Float64Array[] }}\n     */\n    private _iteration;\n    /**\n     * @private\n     * @param {number} K\n     * @returns {Float64Array[]}\n     */\n    private _compute_centroid;\n}\nimport type { ParametersKMeans } from \"./index.js\";\nimport { Clustering } from \"./Clustering.js\";\nimport { Randomizer } from \"../util/index.js\";\nimport type { InputType } from \"../index.js\";\n//# sourceMappingURL=KMeans.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import { ParametersKMedoids } from \"./index.js\" */\n/**\n * K-Medoids (PAM - Partitioning Around Medoids)\n *\n * A robust clustering algorithm similar to K-Means, but uses actual data points (medoids)\n * as cluster centers and can work with any distance metric.\n *\n * @class\n * @extends Clustering<ParametersKMedoids>\n * @category Clustering\n * @see {@link KMeans} for a faster but less robust alternative\n */\nexport class KMedoids extends Clustering<ParametersKMedoids> {\n    /**\n     * @param {InputType} points - Data matrix\n     * @param {Partial<ParametersKMedoids>} parameters\n     * @see {@link https://link.springer.com/chapter/10.1007/978-3-030-32047-8_16} Faster k-Medoids Clustering: Improving the PAM, CLARA, and CLARANS Algorithms\n     */\n    constructor(points: InputType, parameters?: Partial<ParametersKMedoids>);\n    _A: Float64Array<ArrayBufferLike>[];\n    _max_iter: number;\n    _distance_matrix: Matrix;\n    _randomizer: Randomizer;\n    _clusters: any[];\n    _cluster_medoids: number[];\n    _is_initialized: boolean;\n    /** @returns {number[]} The cluster list */\n    get_cluster_list(): number[];\n    /** @returns {number[][]} - Array of clusters with the indices of the rows in given points. */\n    get_clusters(): number[][];\n    /** @returns {number} */\n    get k(): number;\n    /** @returns {number[]} */\n    get medoids(): number[];\n    /** @returns {number[]} */\n    get_medoids(): number[];\n    generator(): AsyncGenerator<number[][], void, unknown>;\n    /** Algorithm 1. FastPAM1: Improved SWAP algorithm */\n    /** FastPAM1: One best swap per iteration */\n    _iteration(): boolean;\n    /**\n     *\n     * @param {number} i\n     * @param {number} j\n     * @param {Float64Array?} x_i\n     * @param {Float64Array?} x_j\n     * @returns\n     */\n    _get_distance(i: number, j: number, x_i?: Float64Array | null, x_j?: Float64Array | null): number;\n    /**\n     *\n     * @param {Float64Array} x_j\n     * @param {number} j\n     * @returns\n     */\n    _nearest_medoid(x_j: Float64Array, j: number): {\n        distance_nearest: number;\n        index_nearest: number;\n        distance_second: number;\n        index_second: number;\n    };\n    _update_clusters(): void;\n    /**\n     * Computes `K` clusters out of the `matrix`.\n     * @param {number} K - Number of clusters.\n     * @param {number[]} cluster_medoids\n     */\n    init(K: number, cluster_medoids: number[]): this;\n    /**\n     * Algorithm 3. FastPAM LAB: Linear Approximate BUILD initialization.\n     *\n     * @param {number} K - Number of clusters\n     * @returns {number[]}\n     */\n    _get_random_medoids(K: number): number[];\n}\nimport type { ParametersKMedoids } from \"./index.js\";\nimport { Clustering } from \"./Clustering.js\";\nimport { Matrix } from \"../matrix/index.js\";\nimport { Randomizer } from \"../util/index.js\";\nimport type { InputType } from \"../index.js\";\n//# sourceMappingURL=KMedoids.d.ts.map","/** @import { ParametersMeanShift } from \"./index.js\" */\n/** @import { InputType } from \"../index.js\" */\n/**\n * Mean Shift Clustering\n *\n * A non-parametric clustering technique that does not require prior knowledge of the\n * number of clusters. It identifies centers of density in the data.\n *\n * @class\n * @extends Clustering<ParametersMeanShift>\n * @category Clustering\n */\nexport class MeanShift extends Clustering<ParametersMeanShift> {\n    /**\n     *\n     * @param {InputType} points\n     * @param {Partial<ParametersMeanShift>} parameters\n     */\n    constructor(points: InputType, parameters?: Partial<ParametersMeanShift>);\n    /** @type {number} */\n    _bandwidth: number;\n    /** @type {number} */\n    _max_iter: number;\n    /** @type {number} */\n    _tolerance: number;\n    /** @type {(dist: number) => number} */\n    _kernel: (dist: number) => number;\n    /** @type {Matrix} */\n    _points: Matrix;\n    /** @type {number[] | undefined} */\n    _clusters: number[] | undefined;\n    /** @type {number[][] | undefined} */\n    _cluster_list: number[][] | undefined;\n    /**\n     * @param {Matrix} matrix\n     * @returns {number}\n     */\n    _compute_bandwidth(matrix: Matrix): number;\n    /**\n     * @param {number} dist\n     * @returns {number}\n     */\n    _kernel_weight(dist: number): number;\n    _mean_shift(): void;\n    _assign_clusters(): void;\n    /**\n     * @returns {number[][]}\n     */\n    get_clusters(): number[][];\n    /**\n     *\n     * @returns {number[]}\n     */\n    get_cluster_list(): number[];\n}\nimport type { ParametersMeanShift } from \"./index.js\";\nimport { Clustering } from \"./Clustering.js\";\nimport { Matrix } from \"../matrix/index.js\";\nimport type { InputType } from \"../index.js\";\n//# sourceMappingURL=MeanShift.d.ts.map","/** @import { InputType } from \"../index.js\" */\n/** @import { ParametersOptics } from \"./index.js\" */\n/** @typedef {Object} DBEntry\n * @property {Float64Array} element\n * @property {number} index\n * @property {number} [reachability_distance]\n * @property {boolean} processed\n * @property {DBEntry[]} [neighbors]\n */\n/**\n * OPTICS (Ordering Points To Identify the Clustering Structure)\n *\n * A density-based clustering algorithm that extends DBSCAN. It handles clusters of varying\n * densities and produces a reachability plot that can be used to extract clusters.\n *\n * @class\n * @extends Clustering<ParametersOptics>\n * @category Clustering\n */\nexport class OPTICS extends Clustering<ParametersOptics> {\n    /**\n     * **O**rdering **P**oints **T**o **I**dentify the **C**lustering **S**tructure.\n     *\n     * @param {InputType} points - The data.\n     * @param {Partial<ParametersOptics>} [parameters={}]\n     * @see {@link https://www.dbs.ifi.lmu.de/Publikationen/Papers/OPTICS.pdf}\n     * @see {@link https://en.wikipedia.org/wiki/OPTICS_algorithm}\n     */\n    constructor(points: InputType, parameters?: Partial<ParametersOptics>);\n    /**\n     * @private\n     * @type {DBEntry[]}\n     */\n    private _ordered_list;\n    /** @type {number[][]} */\n    _clusters: number[][];\n    /**\n     * @private\n     * @type {DBEntry[]}\n     */\n    private _DB;\n    _cluster_index: number;\n    /**\n     * @private\n     * @param {DBEntry} p - A point of the data.\n     * @returns {DBEntry[]} An array consisting of the `epsilon`-neighborhood of `p`.\n     */\n    private _get_neighbors;\n    /**\n     * @private\n     * @param {DBEntry} p - A point of `matrix`.\n     * @returns {number|undefined} The distance to the `min_points`-th nearest point of `p`, or undefined if the\n     *   `epsilon`-neighborhood has fewer elements than `min_points`.\n     */\n    private _core_distance;\n    /**\n     * Updates the reachability distance of the points.\n     *\n     * @private\n     * @param {DBEntry} p\n     * @param {Heap<DBEntry>} seeds\n     */\n    private _update;\n    /**\n     * Expands the `cluster` with points in `seeds`.\n     *\n     * @private\n     * @param {Heap<DBEntry>} seeds\n     * @param {number[]} cluster\n     */\n    private _expand_cluster;\n    /**\n     * Returns an array of clusters.\n     *\n     * @returns {number[][]} Array of clusters with the indices of the rows in given `matrix`.\n     */\n    get_clusters(): number[][];\n    /**\n     * @returns {number[]} Returns an array, where the ith entry defines the cluster affirmation of the ith point of\n     *   given data. (-1 stands for outlier)\n     */\n    get_cluster_list(): number[];\n}\nexport type DBEntry = {\n    element: Float64Array;\n    index: number;\n    reachability_distance?: number | undefined;\n    processed: boolean;\n    neighbors?: DBEntry[] | undefined;\n};\nimport type { ParametersOptics } from \"./index.js\";\nimport { Clustering } from \"./Clustering.js\";\nimport type { InputType } from \"../index.js\";\n//# sourceMappingURL=OPTICS.d.ts.map","/** @import { InputType } from \"../index.js\" */\n/** @import { ParametersXMeans } from \"./index.js\" */\n/**\n * @typedef SplitResult\n * @property {number} index - Index of the cluster being split\n * @property {number} bic_parent - BIC score of the parent cluster\n * @property {number} bic_children - BIC score of the split children\n * @property {number[][]} child_clusters - Clusters after splitting\n * @property {Float64Array[]} child_centroids - Centroids of child clusters\n */\n/**\n * @typedef CandidateResult\n * @property {KMeans} kmeans - The KMeans instance for this K\n * @property {number} score - BIC score\n */\n/**\n * X-Means Clustering\n *\n * An extension of K-Means that automatically determines the number of clusters (K)\n * using the Bayesian Information Criterion (BIC).\n *\n * @class\n * @extends Clustering<ParametersXMeans>\n * @category Clustering\n */\nexport class XMeans extends Clustering<ParametersXMeans> {\n    /**\n     * XMeans clustering algorithm that automatically determines the optimal number of clusters.\n     *\n     * X-Means extends K-Means by starting with a minimum number of clusters and iteratively\n     * splitting clusters to improve the Bayesian Information Criterion (BIC).\n     *\n     * Algorithm:\n     * 1. Start with K_min clusters using KMeans\n     * 2. For each cluster, try splitting it into 2 sub-clusters\n     * 3. If BIC improves after splitting, keep the split\n     * 4. Run KMeans again with all (old + new) centroids\n     * 5. Repeat until K_max is reached or no more improvements\n     *\n     * @param {InputType} points - The data points to cluster\n     * @param {Partial<ParametersXMeans>} [parameters={}] - Configuration parameters\n     * @see {@link https://www.cs.cmu.edu/~dpelleg/download/xmeans.pdf}\n     * @see {@link https://github.com/annoviko/pyclustering/blob/master/pyclustering/cluster/xmeans.py}\n     * @see {@link https://github.com/haifengl/smile/blob/master/core/src/main/java/smile/clustering/XMeans.java}\n     */\n    constructor(points: InputType, parameters?: Partial<ParametersXMeans>);\n    _randomizer: Randomizer;\n    /** @type {KMeans | null} */\n    _best_kmeans: KMeans | null;\n    /**\n     * Run the XMeans algorithm\n     *\n     * @private\n     */\n    private _run;\n    /**\n     * Select the best candidate based on BIC score\n     *\n     * @private\n     * @param {Map<number, CandidateResult>} candidates\n     * @returns {KMeans}\n     */\n    private _select_best_candidate;\n    /**\n     * Calculate Bayesian Information Criterion for a set of clusters.\n     *\n     * Uses Kass's formula for BIC calculation:\n     * BIC(θ) = L(D) - 0.5 * p * ln(N)\n     *\n     * Where:\n     * - L(D) is the log-likelihood of the data\n     * - p is the number of free parameters: (K-1) + D*K + 1\n     * - N is the total number of points\n     *\n     * @private\n     * @param {number[][]} clusters - Array of clusters with point indices\n     * @param {Float64Array[]} centroids - Array of centroids\n     * @returns {number} BIC score (higher is better)\n     */\n    private _bic;\n    /**\n     * Get the computed clusters\n     *\n     * @returns {number[][]} Array of clusters, each containing indices of points\n     */\n    get_clusters(): number[][];\n    /** @returns {number[]} The cluster list */\n    get_cluster_list(): number[];\n    /**\n     * Get the final centroids\n     *\n     * @returns {Float64Array[]} Array of centroids\n     */\n    get centroids(): Float64Array[];\n    /**\n     * Get the optimal number of clusters found\n     *\n     * @returns {number} The number of clusters\n     */\n    get k(): number;\n}\nexport type SplitResult = {\n    /**\n     * - Index of the cluster being split\n     */\n    index: number;\n    /**\n     * - BIC score of the parent cluster\n     */\n    bic_parent: number;\n    /**\n     * - BIC score of the split children\n     */\n    bic_children: number;\n    /**\n     * - Clusters after splitting\n     */\n    child_clusters: number[][];\n    /**\n     * - Centroids of child clusters\n     */\n    child_centroids: Float64Array[];\n};\nexport type CandidateResult = {\n    /**\n     * - The KMeans instance for this K\n     */\n    kmeans: KMeans;\n    /**\n     * - BIC score\n     */\n    score: number;\n};\nimport type { ParametersXMeans } from \"./index.js\";\nimport { Clustering } from \"./Clustering.js\";\nimport { Randomizer } from \"../util/index.js\";\nimport { KMeans } from \"./KMeans.js\";\nimport type { InputType } from \"../index.js\";\n//# sourceMappingURL=XMeans.d.ts.map","export { CURE } from \"./CURE.js\";\nexport { HierarchicalClustering } from \"./Hierarchical_Clustering.js\";\nexport { KMeans } from \"./KMeans.js\";\nexport { KMedoids } from \"./KMedoids.js\";\nexport { MeanShift } from \"./MeanShift.js\";\nexport { OPTICS } from \"./OPTICS.js\";\nexport { XMeans } from \"./XMeans.js\";\nexport type ParametersHierarchicalClustering = {\n    linkage: \"single\" | \"complete\" | \"average\";\n    metric: Metric | \"precomputed\";\n};\nexport type ParametersKMeans = {\n    K: number;\n    /**\n     * Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * Default is `1212`\n     */\n    seed: number;\n    /**\n     * - Initial centroids. Default is `null`\n     */\n    initial_centroids?: Float64Array<ArrayBufferLike>[] | number[][] | undefined;\n};\nexport type ParametersKMedoids = {\n    /**\n     * - Number of clusters\n     */\n    K: number;\n    /**\n     * - Maximum number of iterations. Default is 10 * Math.log10(N). Default is `null`\n     */\n    max_iter: number | null;\n    /**\n     * - Metric defining the dissimilarity. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * - Seed value for random number generator. Default is `1212`\n     */\n    seed: number;\n};\nexport type ParametersOptics = {\n    /**\n     * - The minimum distance which defines whether a point is a neighbor or not.\n     */\n    epsilon: number;\n    /**\n     * - The minimum number of points which a point needs to create a cluster. (Should be higher than 1, else each point creates a cluster.)\n     */\n    min_points: number;\n    /**\n     * - The distance metric which defines the distance between two points of the points. Default is `euclidean`\n     */\n    metric: Metric;\n};\nexport type ParametersXMeans = {\n    /**\n     * - Minimum number of clusters. Default is `2`\n     */\n    K_min: number;\n    /**\n     * - Maximum number of clusters. Default is `10`\n     */\n    K_max: number;\n    /**\n     * - Distance metric function. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * - Random seed. Default is `1212`\n     */\n    seed: number;\n    /**\n     * - Minimum points required to consider splitting a cluster. Default is `25`\n     */\n    min_cluster_size: number;\n    /**\n     * - Convergence tolerance for KMeans. Default is `0.001`\n     */\n    tolerance: number;\n};\nexport type ParametersMeanShift = {\n    /**\n     * - bandwidth\n     */\n    bandwidth: number;\n    /**\n     * - Metric defining the dissimilarity. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * - Seed value for random number generator. Default is `1212`\n     */\n    seed: number;\n    /**\n     * - Kernel function. Default is `gaussian`\n     */\n    kernel: \"flat\" | \"gaussian\" | ((dist: number) => number);\n    /**\n     * - Maximum number of iterations. Default is `Math.max(10, Math.floor(10 * Math.log10(N)))`\n     */\n    max_iter?: number | undefined;\n    /**\n     * - Convergence tolerance. Default is `1e-3`\n     */\n    tolerance?: number | undefined;\n};\nexport type ParametersCURE = {\n    /**\n     * - Target number of clusters. Default is `2`\n     */\n    K: number;\n    /**\n     * - Number of representative points per cluster. Default is `5`\n     */\n    num_representatives: number;\n    /**\n     * - Factor to shrink representatives toward centroid (0-1). Default is `0.5`\n     */\n    shrink_factor: number;\n    /**\n     * - Distance metric function. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * - Random seed. Default is `1212`\n     */\n    seed: number;\n};\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=index.d.ts.map","/**\n * @template T\n * @typedef {Object} DisjointSetPayload\n * @property {T} parent\n * @property {Set<T>} children\n * @property {number} size\n */\n/**\n * @template T\n * @class\n * @category Data Structures\n * @see {@link https://en.wikipedia.org/wiki/Disjoint-set_data_structure}\n */\nexport class DisjointSet<T> {\n    /**\n     * @param {T[]?} elements\n     */\n    constructor(elements?: T[] | null);\n    /**\n     * @private\n     * @type {Map<T, DisjointSetPayload<T>>}\n     */\n    private _list;\n    /**\n     * @private\n     * @param {T} x\n     * @returns {DisjointSet<T>}\n     */\n    private make_set;\n    /**\n     * @param {T} x\n     * @returns\n     */\n    find(x: T): T | null;\n    /**\n     * @param {T} x\n     * @param {T} y\n     * @returns\n     */\n    union(x: T, y: T): this;\n    /** @param {T} x */\n    get_children(x: T): Set<T> | null;\n}\nexport type DisjointSetPayload<T> = {\n    parent: T;\n    children: Set<T>;\n    size: number;\n};\n//# sourceMappingURL=DisjointSet.d.ts.map","/** @import { Comparator } from \"./index.js\" */\n/**\n * @template T\n * @class\n * @category Data Structures\n */\nexport class Heap<T> {\n    /**\n     * Creates a Heap from an Array\n     *\n     * @template T\n     * @param {T[]} elements - Contains the elements for the Heap.\n     * @param {(d: T) => number} accessor - Function returns the value of the element.\n     * @param {\"min\" | \"max\" | Comparator} [comparator=\"min\"] - Function returning true or false\n     *   defining the wished order of the Heap, or String for predefined function. (\"min\" for a Min-Heap, \"max\" for a\n     *   Max_heap). Default is `\"min\"`\n     * @returns {Heap<T>}\n     */\n    static heapify<T_1>(elements: T_1[], accessor: (d: T_1) => number, comparator?: \"min\" | \"max\" | Comparator): Heap<T_1>;\n    /**\n     * A heap is a datastructure holding its elements in a specific way, so that the top element would be the first\n     * entry of an ordered list.\n     *\n     * @param {T[]?} elements - Contains the elements for the Heap. `elements` can be null.\n     * @param {(d: T) => number} accessor - Function returns the value of the element.\n     * @param {\"min\" | \"max\" | Comparator} [comparator=\"min\"] - Function returning true or false\n     *   defining the wished order of the Heap, or String for predefined function. (\"min\" for a Min-Heap, \"max\" for a\n     *   Max_heap). Default is `\"min\"`\n     * @see {@link https://en.wikipedia.org/wiki/Binary_heap}\n     */\n    constructor(elements: (T[] | null) | undefined, accessor: (d: T) => number, comparator?: \"min\" | \"max\" | Comparator);\n    /** @type {{ element: T; value: number }[]} */\n    _container: {\n        element: T;\n        value: number;\n    }[];\n    /** @type {Comparator} */\n    _comparator: Comparator;\n    /** @type {(d: T) => number} */\n    _accessor: (d: T) => number;\n    /**\n     * Swaps elements of container array.\n     *\n     * @private\n     * @param {number} index_a\n     * @param {number} index_b\n     */\n    private _swap;\n    /** @private */\n    private _heapify_up;\n    /**\n     * Pushes the element to the heap.\n     *\n     * @param {T} element\n     * @returns {Heap<T>}\n     */\n    push(element: T): Heap<T>;\n    /**\n     * @private\n     * @param {Number} [start_index=0] Default is `0`\n     */\n    private _heapify_down;\n    /**\n     * Removes and returns the top entry of the heap.\n     *\n     * @returns {{ element: T; value: number } | null} Object consists of the element and its value (computed by\n     *   `accessor`}).\n     */\n    pop(): {\n        element: T;\n        value: number;\n    } | null;\n    /**\n     * Returns the top entry of the heap without removing it.\n     *\n     * @returns {{ element: T; value: number } | null} Object consists of the element and its value (computed by\n     *   `accessor`).\n     */\n    get first(): {\n        element: T;\n        value: number;\n    } | null;\n    /**\n     * Yields the raw data\n     *\n     * @yields {T} Object consists of the element and its value (computed by `accessor`}).\n     */\n    iterate(): Generator<T, void, unknown>;\n    /**\n     * Returns the heap as ordered array.\n     *\n     * @returns {T[]} Array consisting the elements ordered by `comparator`.\n     */\n    toArray(): T[];\n    /**\n     * Returns elements of container array.\n     *\n     * @returns {T[]} Array consisting the elements.\n     */\n    data(): T[];\n    /**\n     * Returns the container array.\n     *\n     * @returns {{ element: T; value: number }[]} The container array.\n     */\n    raw_data(): {\n        element: T;\n        value: number;\n    }[];\n    /**\n     * The size of the heap.\n     *\n     * @returns {number}\n     */\n    get length(): number;\n    /**\n     * Returns false if the the heap has entries, true if the heap has no entries.\n     *\n     * @returns {boolean}\n     */\n    get empty(): boolean;\n}\nimport type { Comparator } from \"./index.js\";\n//# sourceMappingURL=Heap.d.ts.map","export { DisjointSet } from \"./DisjointSet.js\";\nexport { Heap } from \"./Heap.js\";\nexport type Comparator = (a: number, b: number) => boolean;\n//# sourceMappingURL=index.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/**\n * @abstract\n * @template {InputType} T\n * @template {{ seed?: number }} Para\n *\n * Base class for all Dimensionality Reduction (DR) algorithms.\n *\n * Provides a common interface for parameters management, data initialization,\n * and transformation (both synchronous and asynchronous).\n *\n * @class\n */\nexport class DR<T extends InputType, Para extends {\n    seed?: number;\n}> {\n    /**\n     * Computes the projection.\n     *\n     * @template {InputType} T\n     * @template {{ seed?: number }} Para\n     * @param {T} X\n     * @param {Para} parameters\n     * @param {...unknown} args - Takes the same arguments of the constructor of the respective DR method.\n     * @returns {T} The dimensionality reduced dataset.\n     */\n    static transform<T_1 extends InputType, Para_1 extends {\n        seed?: number;\n    }>(X: T_1, parameters: Para_1, ...args: unknown[]): T_1;\n    /**\n     * Computes the projection.\n     *\n     * @template {{ seed?: number }} Para\n     * @param {InputType} X\n     * @param {Para} parameters\n     * @param {...unknown} args - Takes the same arguments of the constructor of the respective DR method.\n     * @returns {Generator<InputType, InputType, void>} A generator yielding the intermediate steps of the dimensionality\n     *   reduction method.\n     */\n    static generator<Para_1 extends {\n        seed?: number;\n    }>(X: InputType, parameters: Para_1, ...args: unknown[]): Generator<InputType, InputType, void>;\n    /**\n     * Computes the projection.\n     *\n     * @template {{ seed?: number }} Para\n     * @param {InputType} X\n     * @param {Para} parameters\n     * @param {...unknown} args - Takes the same arguments of the constructor of the respective DR method.\n     * @returns {Promise<X>} A promise yielding the dimensionality reduced dataset.\n     */\n    static transform_async<Para_1 extends {\n        seed?: number;\n    }>(X: InputType, parameters: Para_1, ...args: unknown[]): Promise<InputType>;\n    /**\n     * Takes the default parameters and seals them, remembers the type of input `X`, and initializes the random number\n     * generator.\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Para} default_parameters - Object containing default parameterization of the DR method.\n     * @param {Partial<Para>} parameters - Object containing parameterization of the DR method to override defaults.\n     */\n    constructor(X: T, default_parameters: Para, parameters?: Partial<Para>);\n    /** @type {number} */\n    _D: number;\n    /** @type {number} */\n    _N: number;\n    /** @type {Randomizer} */\n    _randomizer: Randomizer;\n    /** @type {boolean} */\n    _is_initialized: boolean;\n    /** @type {T} */\n    __input: T;\n    /** @type {Para} */\n    _parameters: Para;\n    /** @type {\"array\" | \"matrix\" | \"typed\"} */\n    _type: \"array\" | \"matrix\" | \"typed\";\n    /** @type {Matrix} */\n    X: Matrix;\n    /** @type {Matrix} */\n    Y: Matrix;\n    /**\n     * Get all Parameters.\n     * @overload\n     * @returns {Para}\n     */\n    parameter(): Para;\n    /**\n     * Get value of given parameter.\n     * @template {keyof Para} K\n     * @overload\n     * @param {K} name - Name of the parameter.\n     * @returns {Para[K]}\n     */\n    parameter<K extends keyof Para>(name: K): Para[K];\n    /**\n     * Set value of given parameter.\n     * @template {keyof Para} K\n     * @overload\n     * @param {K} name - Name of the parameter.\n     * @param {Para[K]} value - Value of the parameter to set.\n     * @returns {this}\n     */\n    parameter<K extends keyof Para>(name: K, value: Para[K]): this;\n    /**\n     * Computes the projection.\n     *\n     * @abstract\n     * @param {...unknown} args\n     * @returns {T} The projection.\n     */\n    transform(...args: unknown[]): T;\n    /**\n     * Computes the projection.\n     *\n     * @abstract\n     * @param {...unknown} args\n     * @returns {Generator<T, T, void>} The intermediate steps of the projection.\n     */\n    generator(...args: unknown[]): Generator<T, T, void>;\n    /**\n     * @abstract\n     * @param {...unknown} args\n     */\n    init(...args: unknown[]): void;\n    /**\n     * If the respective DR method has an `init` function, call it before `transform`.\n     *\n     * @returns {DR<T, Para>}\n     */\n    check_init(): DR<T, Para>;\n    /** @returns {T} The projection in the type of input `X`. */\n    get projection(): T;\n    /**\n     * Computes the projection.\n     *\n     * @param {...unknown} args - Arguments the transform method of the respective DR method takes.\n     * @returns {Promise<T>} The dimensionality reduced dataset.\n     */\n    transform_async(...args: unknown[]): Promise<T>;\n}\nimport type { InputType } from \"../index.js\";\nimport { Randomizer } from \"../util/index.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=DR.d.ts.map","/** @import { InputType } from \"../index.js\" */\n/** @import { ParametersFASTMAP } from \"./index.js\"; */\n/**\n * FastMap algorithm for dimensionality reduction.\n *\n * A very fast algorithm for projecting high-dimensional data into a lower-dimensional\n * space while preserving pairwise distances. It works similarly to PCA but uses\n * only a subset of the data to find projection axes.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersFASTMAP>\n * @category Dimensionality Reduction\n */\nexport class FASTMAP<T extends InputType> extends DR<T, ParametersFASTMAP> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersFASTMAP>} parameters\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersFASTMAP>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersFASTMAP>} parameters\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersFASTMAP>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersFASTMAP>} parameters\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersFASTMAP>): Promise<T_1>;\n    /**\n     * FastMap: a fast algorithm for indexing, data-mining and visualization of traditional and multimedia datasets.\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersFASTMAP>} parameters - Object containing parameterization of the DR method.\n     * @see {@link https://doi.org/10.1145/223784.223812}\n     */\n    constructor(X: T, parameters: Partial<ParametersFASTMAP>);\n    /**\n     * Chooses two points which are the most distant in the actual projection.\n     *\n     * @private\n     * @param {(a: number, b: number) => number} dist\n     * @returns {[number, number, number]} An array consisting of first index, second index, and distance between the\n     *   two points.\n     */\n    private _choose_distant_objects;\n    /**\n     * Computes the projection.\n     *\n     * @returns {T} The `d`-dimensional projection of the data matrix `X`.\n     */\n    transform(): T;\n    generator(): Generator<T, T, unknown>;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersFASTMAP } from \"./index.js\";\nimport { DR } from \"./DR.js\";\n//# sourceMappingURL=FASTMAP.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersISOMAP} from \"./index.js\" */\n/** @import {EigenArgs} from \"../linear_algebra/index.js\" */\n/**\n * Isomap (Isometric Mapping)\n *\n * A nonlinear dimensionality reduction algorithm that uses geodesic distances\n * between points on a manifold to perform embedding. It builds a neighborhood\n * graph and uses MDS on the shortest-path distances.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersISOMAP>\n * @category Dimensionality Reduction\n * @see {@link LLE} for another nonlinear alternative\n */\nexport class ISOMAP<T extends InputType> extends DR<T, ParametersISOMAP> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersISOMAP>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersISOMAP>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersISOMAP>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersISOMAP>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersISOMAP>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersISOMAP>): Promise<T_1>;\n    /**\n     * Isometric feature mapping (ISOMAP).\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersISOMAP>} [parameters] - Object containing parameterization of the DR method.\n     * @see {@link https://doi.org/10.1126/science.290.5500.2319}\n     */\n    constructor(X: T, parameters?: Partial<ParametersISOMAP>);\n    defaults: ParametersISOMAP;\n    /**\n     * Computes the projection.\n     *\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection.\n     */\n    generator(): Generator<T, T, void>;\n    /**\n     * @returns {T}\n     */\n    transform(): T;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersISOMAP } from \"./index.js\";\nimport { DR } from \"./DR.js\";\n//# sourceMappingURL=ISOMAP.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersLDA} from \"./index.js\" */\n/** @import {EigenArgs} from \"../linear_algebra/index.js\" */\n/**\n * Linear Discriminant Analysis (LDA)\n *\n * A supervised dimensionality reduction technique that finds the axes that\n * maximize the separation between multiple classes.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersLDA>\n * @category Dimensionality Reduction\n */\nexport class LDA<T extends InputType> extends DR<T, ParametersLDA> {\n    /**\n     * @template {InputType} T\n     * @template {{ seed?: number }} Para\n     * @param {T} X\n     * @param {Para} parameters\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType, Para extends {\n        seed?: number;\n    }>(X: T_1, parameters: Para): T_1;\n    /**\n     * @template {InputType} T\n     * @template {{ seed?: number }} Para\n     * @param {T} X\n     * @param {Para} parameters\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType, Para extends {\n        seed?: number;\n    }>(X: T_1, parameters: Para): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @template {{ seed?: number }} Para\n     * @param {T} X\n     * @param {Para} parameters\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType, Para extends {\n        seed?: number;\n    }>(X: T_1, parameters: Para): Promise<T_1>;\n    /**\n     * Linear Discriminant Analysis.\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersLDA> & { labels: any[] | Float64Array }} parameters - Object containing parameterization of the DR method.\n     * @see {@link https://onlinelibrary.wiley.com/doi/10.1111/j.1469-1809.1936.tb02137.x}\n     */\n    constructor(X: T, parameters: Partial<ParametersLDA> & {\n        labels: any[] | Float64Array;\n    });\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection.\n     */\n    generator(): Generator<T, T, void>;\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {T} - The projected data.\n     */\n    transform(): T;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersLDA } from \"./index.js\";\nimport { DR } from \"./DR.js\";\n//# sourceMappingURL=LDA.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersLLE} from \"./index.js\" */\n/** @import {EigenArgs} from \"../linear_algebra/index.js\" */\n/**\n * Locally Linear Embedding (LLE)\n *\n * A nonlinear dimensionality reduction technique that preserves local\n * linear relationships between points. It represents each point as a linear\n * combination of its neighbors.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersLLE>\n * @category Dimensionality Reduction\n * @see {@link ISOMAP} for another nonlinear alternative\n */\nexport class LLE<T extends InputType> extends DR<T, ParametersLLE> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLLE>} parameters\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersLLE>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLLE>} parameters\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersLLE>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLLE>} parameters\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersLLE>): Promise<T_1>;\n    /**\n     * Locally Linear Embedding.\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersLLE>} parameters - Object containing parameterization of the DR method.\n     * @see {@link https://doi.org/10.1126/science.290.5500.2323}\n     */\n    constructor(X: T, parameters: Partial<ParametersLLE>);\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection.\n     */\n    generator(): Generator<T, T, void>;\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {T}\n     */\n    transform(): T;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersLLE } from \"./index.js\";\nimport { DR } from \"./DR.js\";\n//# sourceMappingURL=LLE.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersLSP} from \"./index.js\" */\n/**\n * Least Square Projection (LSP)\n *\n * A dimensionality reduction technique that uses a small set of control points\n * (projected with MDS) to define the projection for the rest of the data\n * using a Laplacian-based optimization.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersLSP>\n * @category Dimensionality Reduction\n */\nexport class LSP<T extends InputType> extends DR<T, ParametersLSP> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLSP>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersLSP>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLSP>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersLSP>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLSP>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersLSP>): Promise<T_1>;\n    /**\n     * Least Squares Projection.\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersLSP>} [parameters] - Object containing parameterization of the DR method.\n     * @see {@link https://ieeexplore.ieee.org/document/4378370}\n     */\n    constructor(X: T, parameters?: Partial<ParametersLSP>);\n    /**\n     * @returns {LSP<T>}\n     */\n    init(): LSP<T>;\n    _A: Matrix | undefined;\n    _b: Matrix | undefined;\n    /**\n     * Computes the projection.\n     *\n     * @returns {T} Returns the projection.\n     */\n    transform(): T;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersLSP } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=LSP.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersLTSA} from \"./index.js\" */\n/** @import {EigenArgs} from \"../linear_algebra/index.js\" */\n/**\n * Local Tangent Space Alignment (LTSA)\n *\n * A nonlinear dimensionality reduction algorithm that represents the local\n * geometry of the manifold by tangent spaces and then aligns them to reveal\n * the global structure.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersLTSA>\n * @category Dimensionality Reduction\n */\nexport class LTSA<T extends InputType> extends DR<T, ParametersLTSA> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLTSA>} parameters\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersLTSA>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLTSA>} parameters\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersLTSA>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersLTSA>} parameters\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersLTSA>): Promise<T_1>;\n    /**\n     * Local Tangent Space Alignment\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersLTSA>} parameters - Object containing parameterization of the DR method.\n     * @see {@link https://epubs.siam.org/doi/abs/10.1137/S1064827502419154}\n     */\n    constructor(X: T, parameters: Partial<ParametersLTSA>);\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection.\n     */\n    generator(): Generator<T, T, void>;\n    /**\n     * Transforms the inputdata `X` to dimenionality `d`.\n     *\n     * @returns {T}\n     */\n    transform(): T;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersLTSA } from \"./index.js\";\nimport { DR } from \"./DR.js\";\n//# sourceMappingURL=LTSA.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersMDS} from \"./index.js\" */\n/** @import {EigenArgs} from \"../linear_algebra/index.js\" */\n/**\n * Classical Multidimensional Scaling (MDS)\n *\n * A linear dimensionality reduction technique that seeks to preserve the\n * pairwise distances between points as much as possible in the lower-dimensional\n * space.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersMDS>\n * @category Dimensionality Reduction\n * @see {@link PCA} for another linear alternative\n */\nexport class MDS<T extends InputType> extends DR<T, ParametersMDS> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersMDS>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersMDS>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersMDS>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersMDS>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersMDS>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersMDS>): Promise<T_1>;\n    /**\n     * Classical MDS.\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersMDS>} [parameters] - Object containing parameterization of the DR method.\n     */\n    constructor(X: T, parameters?: Partial<ParametersMDS>);\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection.\n     */\n    generator(): Generator<T, T, void>;\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {T}\n     */\n    transform(): T;\n    _d_X: Matrix | undefined;\n    /** @returns {number} - The stress of the projection. */\n    stress(): number;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersMDS } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=MDS.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersPCA} from \"./index.js\" */\n/** @import {EigenArgs} from \"../linear_algebra/index.js\" */\n/**\n * Principal Component Analysis (PCA)\n *\n * A linear dimensionality reduction technique that identifies the axes (principal components)\n * along which the variance of the data is maximized.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersPCA>\n * @category Dimensionality Reduction\n * @see {@link MDS} for another linear alternative\n *\n * @example\n * import * as druid from \"@saehrimnir/druidjs\";\n *\n * const X = [[1, 2], [3, 4], [5, 6]];\n * const pca = new druid.PCA(X, { d: 2 });\n * const Y = pca.transform();\n * // [[x1, y1], [x2, y2], [x3, y3]]\n */\nexport class PCA<T extends InputType> extends DR<T, ParametersPCA> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersPCA>} parameters\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersPCA>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersPCA>} parameters\n     * @returns {Matrix}\n     */\n    static principal_components<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersPCA>): Matrix;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersPCA>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersPCA>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersPCA>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersPCA>): Promise<T_1>;\n    /**\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersPCA>} [parameters] - Object containing parameterization of the DR method.\n     */\n    constructor(X: T, parameters?: Partial<ParametersPCA>);\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection.\n     */\n    generator(): Generator<T, T, void>;\n    /**\n     * Transforms the inputdata `X` to dimensionality `d`.\n     *\n     * @returns {T} - The projected data.\n     */\n    transform(): T;\n    /**\n     * Computes the `d` principal components of Matrix `X`.\n     *\n     * @returns {Matrix}\n     */\n    principal_components(): Matrix;\n    V: Matrix | undefined;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersPCA } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=PCA.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersPCA, ParametersMDS, ParametersSAMMON} from \"./index.js\" */\n/** @typedef {\"PCA\" | \"MDS\" | \"random\"} AvailableInit */\n/** @typedef {{ PCA: ParametersPCA; MDS: ParametersMDS; random: {} }} ChooseDR */\n/**\n * Sammon's Mapping\n *\n * A nonlinear dimensionality reduction technique that minimizes a stress\n * function based on the ratio of pairwise distances in high and low dimensional spaces.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersSAMMON<AvailableInit>>\n * @category Dimensionality Reduction\n */\nexport class SAMMON<T extends InputType> extends DR<T, ParametersSAMMON<AvailableInit>> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSAMMON<AvailableInit>>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSAMMON<AvailableInit>>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSAMMON<AvailableInit>>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSAMMON<AvailableInit>>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSAMMON<AvailableInit>>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSAMMON<AvailableInit>>): Promise<T_1>;\n    /**\n     * SAMMON's Mapping\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersSAMMON<AvailableInit>>} [parameters] - Object containing parameterization of the DR\n     *   method.\n     * @see {@link https://arxiv.org/pdf/2009.01512.pdf}\n     */\n    constructor(X: T, parameters?: Partial<ParametersSAMMON<AvailableInit>>);\n    /** @type {Matrix | undefined} */\n    distance_matrix: Matrix | undefined;\n    /**\n     * Initializes the projection.\n     *\n     * @param {Matrix | undefined} D\n     * @returns {asserts D is Matrix}\n     */\n    init(D: Matrix | undefined): asserts D is Matrix;\n    /**\n     * Transforms the inputdata `X` to dimensionality 2.\n     *\n     * @param {number} [max_iter=200] - Maximum number of iteration steps. Default is `200`\n     * @returns {T} The projection of `X`.\n     */\n    transform(max_iter?: number): T;\n    /**\n     * Transforms the inputdata `X` to dimenionality 2.\n     *\n     * @param {number} [max_iter=200] - Maximum number of iteration steps. Default is `200`\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection of\n     *   `X`.\n     */\n    generator(max_iter?: number): Generator<T, T, void>;\n    _step(): Matrix;\n}\nexport type AvailableInit = \"PCA\" | \"MDS\" | \"random\";\nexport type ChooseDR = {\n    PCA: ParametersPCA;\n    MDS: ParametersMDS;\n    random: {};\n};\nimport type { InputType } from \"../index.js\";\nimport type { ParametersSAMMON } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\nimport type { ParametersPCA } from \"./index.js\";\nimport type { ParametersMDS } from \"./index.js\";\n//# sourceMappingURL=SAMMON.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersSMACOF} from \"./index.js\" */\n/**\n * Metric Multidimensional Scaling (MDS) via SMACOF.\n *\n * SMACOF (Scaling by Majorizing a Complicated Function) is an iterative majorization\n * algorithm for solving metric multidimensional scaling problems, which aims to\n * minimize the stress function.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersSMACOF>\n * @category Dimensionality Reduction\n * @see {@link MDS} for the classical approach.\n */\nexport class SMACOF<T extends InputType> extends DR<T, ParametersSMACOF> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSMACOF>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSMACOF>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSMACOF>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSMACOF>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSMACOF>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSMACOF>): Promise<T_1>;\n    /**\n     * SMACOF for MDS.\n     *\n     * @param {T} X - The high-dimensional data or precomputed distance matrix.\n     * @param {Partial<ParametersSMACOF>} [parameters] - Object containing parameterization.\n     */\n    constructor(X: T, parameters?: Partial<ParametersSMACOF>);\n    /**\n     * @returns {Generator<T, T, void>} A generator yielding the intermediate steps of the projection.\n     */\n    generator(): Generator<T, T, void>;\n    /**\n     * @returns {T}\n     */\n    transform(): T;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersSMACOF } from \"./index.js\";\nimport { DR } from \"./DR.js\";\n//# sourceMappingURL=SMACOF.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {Metric} from \"../metrics/index.js\" */\n/** @import {ParametersSQDMDS} from \"./index.js\" */\n/**\n * SQuadMDS (Stochastic Quartet MDS)\n *\n * A lean Stochastic Quartet MDS improving global structure preservation in\n * neighbor embedding like t-SNE and UMAP.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersSQDMDS>\n * @category Dimensionality Reduction\n */\nexport class SQDMDS<T extends InputType> extends DR<T, ParametersSQDMDS> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSQDMDS>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSQDMDS>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSQDMDS>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSQDMDS>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersSQDMDS>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersSQDMDS>): Promise<T_1>;\n    /**\n     * SQuadMDS: a lean Stochastic Quartet MDS improving global structure preservation in neighbor embedding like t-SNE\n     * and UMAP.\n     *\n     * @param {T} X\n     * @param {Partial<ParametersSQDMDS>} [parameters]\n     * @see {@link https://arxiv.org/pdf/2202.12087.pdf}\n     */\n    constructor(X: T, parameters?: Partial<ParametersSQDMDS>);\n    init(): void;\n    _add: ((...summands: Float64Array<ArrayBufferLike>[]) => Float64Array) | undefined;\n    _sub_div: ((x: Float64Array<ArrayBufferLike>, y: Float64Array<ArrayBufferLike>, div: number) => Float64Array) | undefined;\n    _minus: ((a: Float64Array<ArrayBufferLike>, b: Float64Array<ArrayBufferLike>) => Float64Array) | undefined;\n    _mult: ((a: Float64Array<ArrayBufferLike>, v: number) => Float64Array) | undefined;\n    _LR_init: number | undefined;\n    _LR: number | undefined;\n    _offset: number | undefined;\n    _momentums: Matrix | undefined;\n    _grads: Matrix | undefined;\n    _indices: number[] | undefined;\n    /** @type {(i: number, j: number, X: Matrix) => number} */\n    _HD_metric: ((i: number, j: number, X: Matrix) => number) | undefined;\n    /** @type {(i: number, j: number, X: Matrix) => number} */\n    _HD_metric_exaggeration: ((i: number, j: number, X: Matrix) => number) | undefined;\n    /**\n     * Computes the projection.\n     *\n     * @param {number} [iterations=500] - Number of iterations. Default is `500`\n     * @returns {T} The projection.\n     */\n    transform(iterations?: number): T;\n    _decay_start: number | undefined;\n    /**\n     * Computes the projection.\n     *\n     * @param {number} [iterations=500] - Number of iterations. Default is `500`\n     * @returns {Generator<T, T, void>} The intermediate steps of the projection.\n     */\n    generator(iterations?: number): Generator<T, T, void>;\n    /**\n     * Performs an optimization step.\n     *\n     * @private\n     * @param {number} i - Acutal iteration.\n     * @param {number} iterations - Number of iterations.\n     */\n    private _step;\n    _distance_exaggeration: boolean | undefined;\n    /**\n     * Creates quartets of non overlapping indices.\n     *\n     * @private\n     * @returns {Uint32Array[]}\n     */\n    private __quartets;\n    /**\n     * Computes and applies gradients, and updates momentum.\n     *\n     * @private\n     * @param {boolean} distance_exaggeration\n     */\n    private _nestrov_iteration;\n    /**\n     * Computes the gradients.\n     *\n     * @param {Matrix} Y - The Projection.\n     * @param {Matrix} grads - The gradients.\n     * @param {boolean} [exaggeration=false] - Whether or not to use early exaggeration. Default is `false`\n     * @param {boolean} [zero_grad=true] - Whether or not to reset the gradient in the beginning. Default is `true`\n     * @returns {Matrix} The gradients.\n     */\n    _fill_MDS_grads(Y: Matrix, grads: Matrix, exaggeration?: boolean, zero_grad?: boolean): Matrix;\n    /**\n     * Quartet gradients for a projection.\n     *\n     * @private\n     * @param {Matrix} Y - The acutal projection.\n     * @param {number[]} quartet - The indices of the quartet.\n     * @param {Float64Array} D_hd - The high-dimensional distances of the quartet.\n     * @returns {Float64Array[]} The gradients for the quartet.\n     */\n    private _compute_quartet_grads;\n    /**\n     * Gradients for one element of the loss function's sum.\n     *\n     * @private\n     * @param {Float64Array} a\n     * @param {Float64Array} b\n     * @param {Float64Array} c\n     * @param {Float64Array} d\n     * @param {number} d_ab\n     * @param {number} d_ac\n     * @param {number} d_ad\n     * @param {number} d_bc\n     * @param {number} d_bd\n     * @param {number} d_cd\n     * @param {number} p_ab\n     * @param {number} sum_LD_dist\n     * @returns {Float64Array[]}\n     */\n    private _ABCD_grads;\n    /**\n     * Inline!\n     *\n     * @param {number} d\n     */\n    __minus(d: number): (a: Float64Array<ArrayBufferLike>, b: Float64Array<ArrayBufferLike>) => Float64Array;\n    /**\n     * Inline!\n     *\n     * @param {number} d\n     */\n    __add(d: number): (...summands: Float64Array<ArrayBufferLike>[]) => Float64Array;\n    /**\n     * Inline!\n     *\n     * @param {number} d\n     */\n    __mult(d: number): (a: Float64Array<ArrayBufferLike>, v: number) => Float64Array;\n    /**\n     * Creates a new array `(x - y) / div`.\n     *\n     * @param {number} d\n     */\n    __sub_div(d: number): (x: Float64Array<ArrayBufferLike>, y: Float64Array<ArrayBufferLike>, div: number) => Float64Array;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersSQDMDS } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=SQDMDS.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {ParametersTopoMap} from \"./index.js\" */\n/**\n * TopoMap\n *\n * A 0-dimensional Homology Preserving Projection of High-Dimensional Data.\n * It aims to preserve the topological structure of the data by maintaining\n * the connectivity of a minimum spanning tree.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersTopoMap>\n * @category Dimensionality Reduction\n */\nexport class TopoMap<T extends InputType> extends DR<T, ParametersTopoMap> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTopoMap>} parameters\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersTopoMap>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTopoMap>} parameters\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersTopoMap>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTopoMap>} parameters\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters: Partial<ParametersTopoMap>): Promise<T_1>;\n    /**\n     * TopoMap: A 0-dimensional Homology Preserving Projection of High-Dimensional Data.\n     *\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersTopoMap>} parameters - Object containing parameterization of the DR method.\n     * @see {@link https://arxiv.org/pdf/2009.01512.pdf}\n     */\n    constructor(X: T, parameters: Partial<ParametersTopoMap>);\n    _distance_matrix: Matrix;\n    /**\n     * @private\n     * @param {number} i\n     * @param {number} j\n     * @param {import(\"../metrics/index.js\").Metric} metric\n     * @returns {number}\n     */\n    private __lazy_distance_matrix;\n    /**\n     * Computes the minimum spanning tree, using a given metric\n     *\n     * @private\n     * @param {import(\"../metrics/index.js\").Metric} metric\n     * @see {@link https://en.wikipedia.org/wiki/Kruskal%27s_algorithm}\n     */\n    private _make_minimum_spanning_tree;\n    _disjoint_set: DisjointSet<Float64Array<ArrayBufferLike>> | undefined;\n    /** Initializes TopoMap. Sets all projcted points to zero, and computes a minimum spanning tree. */\n    init(): this;\n    _Emst: number[][] | undefined;\n    /**\n     * Returns true if Point C is left of line AB.\n     *\n     * @private\n     * @param {Float64Array} PointA - Point A of line AB\n     * @param {Float64Array} PointB - Point B of line AB\n     * @param {Float64Array} PointC - Point C\n     * @returns {boolean}\n     */\n    private __hull_cross;\n    /**\n     * Computes the convex hull of the set of Points S\n     *\n     * @private\n     * @param {Float64Array[]} S - Set of Points.\n     * @returns {Float64Array[]} Convex hull of S. Starts at the bottom-most point and continues counter-clockwise.\n     * @see {@link https://en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Convex_hull/Monotone_chain#JavaScript}\n     */\n    private __hull;\n    /**\n     * Finds the angle to rotate Point A and B to lie on a line parallel to the x-axis.\n     *\n     * @private\n     * @param {Float64Array} PointA\n     * @param {Float64Array} PointB\n     * @returns {{ sin: number; cos: number }} Object containing the sinus- and cosinus-values for a rotation.\n     */\n    private __findAngle;\n    /**\n     * @private\n     * @param {Float64Array[]} hull\n     * @param {Float64Array} p\n     * @param {boolean} topEdge\n     * @returns {{ sin: number; cos: number; tx: number; ty: number }}\n     */\n    private __align_hull;\n    /**\n     * @private\n     * @param {Float64Array} Point - The point which should get transformed.\n     * @param {{ sin: number; cos: number; tx: number; ty: number }} Transformation - Contains the values for\n     *   translation and rotation.\n     */\n    private __transform;\n    /**\n     * Calls `__transform` for each point in Set C\n     *\n     * @private\n     * @param {Float64Array[]} C - Set of points.\n     * @param {{ sin: number; cos: number; tx: number; ty: number }} t - Transform object.\n     * @param {number} yOffset - Value to offset set C.\n     */\n    private __transform_component;\n    /**\n     * @private\n     * @param {Float64Array} root_u - Root of component u\n     * @param {Float64Array} root_v - Root of component v\n     * @param {Float64Array} p_u - Point u\n     * @param {Float64Array} p_v - Point v\n     * @param {number} w - Edge weight w\n     * @param {DisjointSet<Float64Array>} components - The disjoint set containing the components\n     */\n    private __align_components;\n    /**\n     * Transforms the inputdata `X` to dimensionality 2.\n     *\n     * @returns {T}\n     */\n    transform(): T;\n    /**\n     * Transforms the inputdata `X` to dimensionality 2.\n     *\n     * @returns {Generator<T, T, void>}\n     */\n    generator(): Generator<T, T, void>;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersTopoMap } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\nimport { DisjointSet } from \"../datastructure/index.js\";\n//# sourceMappingURL=TopoMap.d.ts.map","/**\n * Base class for all K-Nearest Neighbors (KNN) search algorithms.\n *\n * Provides a common interface for elements management and search operations.\n *\n * @abstract\n * @category KNN\n * @template {number[] | Float64Array} T - Type of elements\n * @template {Object} Para - Type of parameters\n * @class\n */\nexport class KNN<T extends number[] | Float64Array, Para extends Object> {\n    /**\n     * @param {T[]} elements\n     * @param {Para} parameters\n     */\n    constructor(elements: T[], parameters: Para);\n    /** @type {T[]} */\n    _elements: T[];\n    /** @type {Para} */\n    _parameters: Para;\n    /** @type {\"typed\" | \"array\"} */\n    _type: \"typed\" | \"array\";\n    /**\n     * @abstract\n     * @param {T} t\n     * @param {number} k\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search(t: T, k: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @abstract\n     * @param {number} i\n     * @param {number} k\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search_by_index(i: number, k: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n}\n//# sourceMappingURL=KNN.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {Metric} from \"../metrics/index.js\" */\n/** @import {ParametersTriMap} from \"./index.js\" */\n/** @import {KNN} from \"../knn/KNN.js\" */\n/**\n * TriMap\n *\n * A dimensionality reduction technique that preserves both local and global\n * structure using triplets. It is designed to be a more robust alternative\n * to t-SNE and UMAP.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersTriMap>\n * @category Dimensionality Reduction\n */\nexport class TriMap<T extends InputType> extends DR<T, ParametersTriMap> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTriMap>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersTriMap>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTriMap>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersTriMap>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTriMap>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersTriMap>): Promise<T_1>;\n    /**\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersTriMap>} [parameters] - Object containing parameterization of the DR method.\n     * @see {@link https://arxiv.org/pdf/1910.00204v1.pdf}\n     * @see {@link https://github.com/eamid/trimap}\n     */\n    constructor(X: T, parameters?: Partial<ParametersTriMap>);\n    /**\n     * @param {Matrix | null} [pca=null] - Initial Embedding (if null then PCA gets used). Default is `null`\n     * @param {import(\"../knn/KNN.js\").KNN<number[] | Float64Array, any> | null} [knn=null] - KNN Object (if null then BallTree gets used). Default is `null`\n     */\n    init(pca?: Matrix | null, knn?: import(\"../knn/KNN.js\").KNN<number[] | Float64Array, any> | null): this;\n    n_inliers: number | undefined;\n    n_outliers: number | undefined;\n    n_random: number | undefined;\n    knn: KNN<number[] | Float64Array<ArrayBufferLike>, any> | undefined;\n    triplets: Matrix | undefined;\n    weights: Float64Array<ArrayBuffer> | undefined;\n    lr: number | undefined;\n    C: number | undefined;\n    vel: Matrix | undefined;\n    gain: Matrix | undefined;\n    /**\n     * Generates {@link n_inliers} x {@link n_outliers} x {@link n_random} triplets.\n     *\n     * @param {number} n_inliers\n     * @param {number} n_outliers\n     * @param {number} n_random\n     */\n    _generate_triplets(n_inliers: number, n_outliers: number, n_random: number): {\n        triplets: Matrix;\n        weights: Float64Array<ArrayBuffer>;\n    };\n    /**\n     * Calculates the similarity matrix P\n     *\n     * @private\n     * @param {Matrix} knn_distances - Matrix of pairwise knn distances\n     * @param {Float64Array} sig - Scaling factor for the distances\n     * @param {Matrix} nbrs - Nearest neighbors\n     * @returns {Matrix} Pairwise similarity matrix\n     */\n    private _find_p;\n    /**\n     * Sample nearest neighbors triplets based on the similarity values given in P.\n     *\n     * @private\n     * @param {Matrix} P - Matrix of pairwise similarities between each point and its neighbors given in matrix nbrs.\n     * @param {Matrix} nbrs - Nearest neighbors indices for each point. The similarity values are given in matrix\n     *   {@link P}. Row i corresponds to the i-th point.\n     * @param {number} n_inliers - Number of inlier points.\n     * @param {number} n_outliers - Number of outlier points.\n     */\n    private _sample_knn_triplets;\n    /**\n     * Should do the same as np.argsort()\n     *\n     * @private\n     * @param {Float64Array | number[]} A\n     */\n    private __argsort;\n    /**\n     * Samples {@link n_samples} integers from a given interval [0, {@link max_int}] while rejection the values that are\n     * in the {@link rejects}.\n     *\n     * @private\n     * @param {number} n_samples\n     * @param {number} max_int\n     * @param {number[]} rejects\n     */\n    private _rejection_sample;\n    /**\n     * Calculates the weights for the sampled nearest neighbors triplets\n     *\n     * @private\n     * @param {Matrix} triplets - Sampled Triplets.\n     * @param {Matrix} P - Pairwise similarity matrix.\n     * @param {Matrix} nbrs - Nearest Neighbors\n     * @param {Float64Array} outlier_distances - Matrix of pairwise outlier distances\n     * @param {Float64Array} sig - Scaling factor for the distances.\n     */\n    private _find_weights;\n    /**\n     * Sample uniformly ranom triplets\n     *\n     * @private\n     * @param {Matrix} X - Data matrix.\n     * @param {number} n_random - Number of random triplets per point\n     * @param {Float64Array} sig - Scaling factor for the distances\n     */\n    private _sample_random_triplets;\n    /**\n     * Computes the gradient for updating the embedding.\n     *\n     * @param {Matrix} Y - The embedding\n     */\n    _grad(Y: Matrix): {\n        grad: Matrix;\n        loss: number;\n        n_viol: number;\n    };\n    /**\n     * @param {number} max_iteration\n     * @returns {T}\n     */\n    transform(max_iteration?: number): T;\n    /**\n     * @param {number} max_iteration\n     * @returns {Generator<T, T, void>}\n     */\n    generator(max_iteration?: number): Generator<T, T, void>;\n    /**\n     * Does the iteration step.\n     *\n     * @private\n     * @param {number} iter\n     */\n    private _next;\n    /**\n     * Updates the embedding.\n     *\n     * @private\n     * @param {Matrix} Y\n     * @param {number} iter\n     * @param {Matrix} grad\n     */\n    private _update_embedding;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersTriMap } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\nimport type { KNN } from \"../knn/KNN.js\";\n//# sourceMappingURL=TriMap.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {Metric} from \"../metrics/index.js\" */\n/** @import {ParametersTSNE} from \"./index.js\" */\n/**\n * t-SNE (t-Distributed Stochastic Neighbor Embedding)\n *\n * A nonlinear dimensionality reduction technique particularly well-suited\n * for visualizing high-dimensional data in 2D or 3D. Preserves local\n * structure while revealing global patterns.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersTSNE>\n * @category Dimensionality Reduction\n * @see {@link https://lvdmaaten.github.io/tsne/|t-SNE Paper}\n * @see {@link UMAP} for faster alternative with similar results\n *\n * @example\n * import * as druid from \"@saehrimnir/druidjs\";\n *\n * const X = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]];\n * const tsne = new druid.TSNE(X, {\n *     perplexity: 30,\n *     epsilon: 10,\n *     d: 2,\n *     seed: 42\n * });\n *\n * const Y = tsne.transform(500); // 500 iterations\n * // [[x1, y1], [x2, y2], [x3, y3]]\n */\nexport class TSNE<T extends InputType> extends DR<T, ParametersTSNE> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTSNE>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersTSNE>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTSNE>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersTSNE>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersTSNE>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersTSNE>): Promise<T_1>;\n    /**\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersTSNE>} [parameters] - Object containing parameterization of the DR method.\n     */\n    constructor(X: T, parameters?: Partial<ParametersTSNE>);\n    _iter: number;\n    init(): this;\n    _ystep: Matrix | undefined;\n    _gains: Matrix | undefined;\n    _P: Matrix | undefined;\n    /**\n     * @param {number} [iterations=500] - Number of iterations. Default is `500`\n     * @returns {T} The projection.\n     */\n    transform(iterations?: number): T;\n    /**\n     * @param {number} [iterations=500] - Number of iterations. Default is `500`\n     * @returns {Generator<T, T, void>} - The projection.\n     */\n    generator(iterations?: number): Generator<T, T, void>;\n    /**\n     * Performs a optimization step\n     *\n     * @private\n     * @returns {Matrix}\n     */\n    private next;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersTSNE } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=TSNE.d.ts.map","/** @import {InputType} from \"../index.js\" */\n/** @import {Metric} from \"../metrics/index.js\" */\n/** @import {ParametersUMAP} from \"./index.js\" */\n/**\n * Uniform Manifold Approximation and Projection (UMAP)\n *\n * A novel manifold learning technique for dimensionality reduction. UMAP is constructed\n * from a theoretical framework based on Riemannian geometry and algebraic topology.\n * It is often faster than t-SNE while preserving more of the global structure.\n *\n * @class\n * @template {InputType} T\n * @extends DR<T, ParametersUMAP>\n * @category Dimensionality Reduction\n * @see {@link https://arxiv.org/abs/1802.03426|UMAP Paper}\n * @see {@link TSNE} for a similar visualization technique\n *\n * @example\n * import * as druid from \"@saehrimnir/druidjs\";\n *\n * const X = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]];\n * const umap = new druid.UMAP(X, {\n *     n_neighbors: 15,\n *     min_dist: 0.1,\n *     d: 2,\n *     seed: 42\n * });\n *\n * const Y = umap.transform(500); // 500 iterations\n * // [[x1, y1], [x2, y2], [x3, y3]]\n */\nexport class UMAP<T extends InputType> extends DR<T, ParametersUMAP> {\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersUMAP>} [parameters]\n     * @returns {T}\n     */\n    static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersUMAP>): T_1;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersUMAP>} [parameters]\n     * @returns {Generator<T, T, void>}\n     */\n    static generator<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersUMAP>): Generator<T_1, T_1, void>;\n    /**\n     * @template {InputType} T\n     * @param {T} X\n     * @param {Partial<ParametersUMAP>} [parameters]\n     * @returns {Promise<T>}\n     */\n    static transform_async<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersUMAP>): Promise<T_1>;\n    /**\n     * @param {T} X - The high-dimensional data.\n     * @param {Partial<ParametersUMAP>} [parameters] - Object containing parameterization of the DR method.\n     */\n    constructor(X: T, parameters?: Partial<ParametersUMAP>);\n    _iter: number;\n    /**\n     * @private\n     * @param {number} spread\n     * @param {number} min_dist\n     * @returns {number[]}\n     */\n    private _find_ab_params;\n    /**\n     * @private\n     * @param {{ element: Float64Array; index: number; distance: number }[][]} distances\n     * @param {number[]} sigmas\n     * @param {number[]} rhos\n     * @returns {{ element: Float64Array; index: number; distance: number }[][]}\n     */\n    private _compute_membership_strengths;\n    /**\n     * @private\n     * @param {NaiveKNN<Float64Array> | BallTree<Float64Array>} knn\n     * @param {number} k\n     * @returns {{\n     *     distances: { element: Float64Array; index: number; distance: number }[][];\n     *     sigmas: number[];\n     *     rhos: number[];\n     * }}\n     */\n    private _smooth_knn_dist;\n    /**\n     * @private\n     * @param {Matrix} X\n     * @param {number} n_neighbors\n     * @returns {Matrix}\n     */\n    private _fuzzy_simplicial_set;\n    /**\n     * @private\n     * @param {number} n_epochs\n     * @returns {Float32Array}\n     */\n    private _make_epochs_per_sample;\n    /**\n     * @private\n     * @param {Matrix} graph\n     * @returns {{ rows: number[]; cols: number[]; data: number[] }}\n     */\n    private _tocoo;\n    /**\n     * Computes all necessary\n     *\n     * @returns {UMAP<T>}\n     */\n    init(): UMAP<T>;\n    _a: number | undefined;\n    _b: number | undefined;\n    _graph: Matrix | undefined;\n    _head: number[] | undefined;\n    _tail: number[] | undefined;\n    _weights: number[] | undefined;\n    _epochs_per_sample: Float32Array<ArrayBufferLike> | undefined;\n    _epochs_per_negative_sample: Float32Array<ArrayBuffer> | undefined;\n    _epoch_of_next_sample: Float32Array<ArrayBuffer> | undefined;\n    _epoch_of_next_negative_sample: Float32Array<ArrayBuffer> | undefined;\n    graph(): {\n        cols: number[] | undefined;\n        rows: number[] | undefined;\n        weights: number[] | undefined;\n    };\n    /**\n     * @param {number} [iterations=350] - Number of iterations. Default is `350`\n     * @returns {T}\n     */\n    transform(iterations?: number): T;\n    /**\n     * @param {number} [iterations=350] - Number of iterations. Default is `350`\n     * @returns {Generator<T, T, void>}\n     */\n    generator(iterations?: number): Generator<T, T, void>;\n    /**\n     * @private\n     * @param {number} x\n     * @returns {number}\n     */\n    private _clip;\n    /**\n     * Performs the optimization step.\n     *\n     * @private\n     * @param {Matrix} head_embedding\n     * @param {Matrix} tail_embedding\n     * @param {number[]} head\n     * @param {number[]} tail\n     * @returns {Matrix}\n     */\n    private _optimize_layout;\n    /**\n     * @private\n     * @returns {Matrix}\n     */\n    private next;\n    _alpha: number | undefined;\n}\nimport type { InputType } from \"../index.js\";\nimport type { ParametersUMAP } from \"./index.js\";\nimport { DR } from \"./DR.js\";\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=UMAP.d.ts.map","/**\n * Computes the inner product between two arrays of the same length.\n *\n * @category Linear Algebra\n * @param {number[] | Float64Array} a - Array a.\n * @param {number[] | Float64Array} b - Array b.\n * @returns The inner product between `a` and `b`.\n */\nexport function inner_product(a: number[] | Float64Array, b: number[] | Float64Array): number;\n//# sourceMappingURL=inner_product.d.ts.map","/**\n * Computes the QR Decomposition of the Matrix `A` using Gram-Schmidt process.\n *\n * @category Linear Algebra\n * @param {Matrix} A\n * @returns {{ R: Matrix; Q: Matrix }}\n * @see {@link https://en.wikipedia.org/wiki/QR_decomposition#Using_the_Gram%E2%80%93Schmidt_process}\n */\nexport function qr(A: Matrix): {\n    R: Matrix;\n    Q: Matrix;\n};\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=qr.d.ts.map","/**\n * Computes the QR Decomposition of the Matrix `A` with householder transformations.\n *\n * @category Linear Algebra\n * @param {Matrix} A\n * @returns {{ R: Matrix; Q: Matrix }}\n * @see {@link https://en.wikipedia.org/wiki/QR_decomposition#Using_Householder_reflections}\n * @see {@link http://mlwiki.org/index.php/Householder_Transformation}\n */\nexport function qr_householder(A: Matrix): {\n    R: Matrix;\n    Q: Matrix;\n};\nimport { Matrix } from \"../matrix/index.js\";\n//# sourceMappingURL=qr_householder.d.ts.map","/** @import { EigenArgs } from \"./index.js\" */\n/**\n * Computes the `k` biggest Eigenvectors and Eigenvalues from Matrix `A` with the QR-Algorithm.\n *\n * @category Linear Algebra\n * @param {Matrix} A - The Matrix\n * @param {number} k - The number of eigenvectors and eigenvalues to compute.\n * @param {EigenArgs} parameters - Object containing parameterization of the simultanious\n *   poweriteration method.\n * @returns {{ eigenvalues: Float64Array; eigenvectors: Float64Array[] }} The `k` biggest eigenvectors and eigenvalues\n *   of Matrix `A`.\n */\nexport function simultaneous_poweriteration(A: Matrix, k?: number, { seed, max_iterations, qr, tol }?: EigenArgs): {\n    eigenvalues: Float64Array;\n    eigenvectors: Float64Array[];\n};\nimport { Matrix } from \"../matrix/index.js\";\nimport type { EigenArgs } from \"./index.js\";\n//# sourceMappingURL=simultaneous_poweriteration.d.ts.map","export { inner_product } from \"./inner_product.js\";\nexport { qr } from \"./qr.js\";\nexport { qr_householder } from \"./qr_householder.js\";\nexport { simultaneous_poweriteration } from \"./simultaneous_poweriteration.js\";\nexport type QRDecomposition = (A: import(\"../matrix/index.js\").Matrix) => {\n    R: import(\"../matrix/index.js\").Matrix;\n    Q: import(\"../matrix/index.js\").Matrix;\n};\nexport type EigenArgs = {\n    /**\n     * - The number of maxiumum iterations the algorithm should run. Default is `100`\n     */\n    max_iterations?: number | undefined;\n    /**\n     * - The seed value or a randomizer used in the algorithm. Default is `1212`\n     */\n    seed?: number | Randomizer | undefined;\n    /**\n     * - The QR technique to use. Default is `qr_gramschmidt`\n     */\n    qr?: QRDecomposition | undefined;\n    /**\n     * - Tolerated error for stopping criteria. Default is `1e-8`\n     */\n    tol?: number | undefined;\n};\nimport type { Randomizer } from \"../util/index.js\";\n//# sourceMappingURL=index.d.ts.map","export { FASTMAP } from \"./FASTMAP.js\";\nexport { ISOMAP } from \"./ISOMAP.js\";\nexport { LDA } from \"./LDA.js\";\nexport { LLE } from \"./LLE.js\";\nexport { LSP } from \"./LSP.js\";\nexport { LTSA } from \"./LTSA.js\";\nexport { MDS } from \"./MDS.js\";\nexport { PCA } from \"./PCA.js\";\nexport { SAMMON } from \"./SAMMON.js\";\nexport { SMACOF } from \"./SMACOF.js\";\nexport { SQDMDS } from \"./SQDMDS.js\";\nexport { TopoMap } from \"./TopoMap.js\";\nexport { TriMap } from \"./TriMap.js\";\nexport { TSNE } from \"./TSNE.js\";\nexport { UMAP } from \"./UMAP.js\";\nexport type ParametersLSP = {\n    /**\n     * - number of neighbors to consider.\n     */\n    neighbors?: number | undefined;\n    /**\n     * - number of controlpoints\n     */\n    control_points?: number | undefined;\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nexport type ParametersFASTMAP = {\n    /**\n     * - The dimensionality of the projection\n     */\n    d?: number | undefined;\n    /**\n     * - The metric which defines the distance between two points.\n     */\n    metric?: Metric | undefined;\n    /**\n     * - The seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nexport type ParametersISOMAP = {\n    /**\n     * - The number of neighbors ISOMAP should use to project the data.\n     */\n    neighbors?: number | undefined;\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | undefined;\n    /**\n     * - Whether to use classical MDS or SMACOF for the final DR.\n     */\n    project?: \"MDS\" | \"SMACOF\" | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n    /**\n     * - Parameters for the eigendecomposition algorithm.\n     */\n    eig_args?: Partial<EigenArgs> | undefined;\n};\nexport type ParametersLDA = {\n    /**\n     * - The labels / classes for each data point.\n     */\n    labels: any[] | Float64Array;\n    /**\n     * - The dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - The seed for the random number generator.\n     */\n    seed?: number | undefined;\n    /**\n     * - Parameters for the eigendecomposition algorithm.\n     */\n    eig_args?: Partial<EigenArgs> | undefined;\n};\nexport type ParametersLLE = {\n    /**\n     * - The number of neighbors for LLE.\n     */\n    neighbors?: number | undefined;\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n    /**\n     * - Parameters for the eigendecomposition algorithm.\n     */\n    eig_args?: Partial<EigenArgs> | undefined;\n};\nexport type ParametersLTSA = {\n    /**\n     * - The number of neighbors for LTSA.\n     */\n    neighbors?: number | undefined;\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n    /**\n     * - Parameters for the eigendecomposition algorithm.\n     */\n    eig_args?: Partial<EigenArgs> | undefined;\n};\nexport type ParametersMDS = {\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | \"precomputed\" | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n    /**\n     * - Parameters for the eigendecomposition algorithm.\n     */\n    eig_args?: Partial<EigenArgs> | undefined;\n};\nexport type ParametersPCA = {\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n    /**\n     * - Parameters for the eigendecomposition algorithm.\n     */\n    eig_args?: Partial<EigenArgs> | undefined;\n};\nexport type ParametersSAMMON<K extends keyof ChooseDR> = {\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | \"precomputed\" | undefined;\n    /**\n     * - Either \"PCA\" or \"MDS\", with which SAMMON initialiates the projection.\n     */\n    init_DR?: K | undefined;\n    /**\n     * - Parameters for the \"init\"-DR method.\n     */\n    init_parameters?: ChooseDR[K] | undefined;\n    /**\n     * - learning rate for gradient descent.\n     */\n    magic?: number | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nexport type ParametersSMACOF = {\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | \"precomputed\" | undefined;\n    /**\n     * - maximum number of iterations.\n     */\n    iterations?: number | undefined;\n    /**\n     * - tolerance for stress difference.\n     */\n    epsilon?: number | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nexport type ParametersSQDMDS = {\n    d?: number | undefined;\n    metric?: Metric | \"precomputed\" | undefined;\n    /**\n     * - Percentage of iterations using exaggeration phase.\n     */\n    decay_start?: number | undefined;\n    /**\n     * - Controls the decay of the learning parameter.\n     */\n    decay_cte?: number | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nexport type ParametersTopoMap = {\n    /**\n     * = euclidean - The metric which defines the distance between\n     * two points.\n     */\n    metric: Metric;\n    /**\n     * = 1212 - The seed for the random number generator.\n     */\n    seed: number;\n};\nexport type ParametersTriMap = {\n    /**\n     * - scaling factor.\n     */\n    weight_adj?: number | undefined;\n    /**\n     * - number of inliers.\n     */\n    n_inliers?: number | undefined;\n    /**\n     * - number of outliers.\n     */\n    n_outliers?: number | undefined;\n    /**\n     * - number of random points.\n     */\n    n_random?: number | undefined;\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    tol?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nexport type ParametersTSNE = {\n    /**\n     * - perplexity.\n     */\n    perplexity?: number | undefined;\n    /**\n     * - learning parameter.\n     */\n    epsilon?: number | undefined;\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points.\n     */\n    metric?: Metric | \"precomputed\" | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nexport type ParametersUMAP = {\n    /**\n     * - size of the local neighborhood.\n     */\n    n_neighbors?: number | undefined;\n    /**\n     * - number of nearest neighbors connected in the local neighborhood.\n     */\n    local_connectivity?: number | undefined;\n    /**\n     * - controls how tightly points get packed together.\n     */\n    min_dist?: number | undefined;\n    /**\n     * - the dimensionality of the projection.\n     */\n    d?: number | undefined;\n    /**\n     * - the metric which defines the distance between two points in the high-dimensional space.\n     */\n    metric?: Metric | \"precomputed\" | undefined;\n    /**\n     * - The effective scale of embedded points.\n     */\n    _spread?: number | undefined;\n    /**\n     * - Interpolate between union and intersection.\n     */\n    _set_op_mix_ratio?: number | undefined;\n    /**\n     * - Weighting applied to negative samples.\n     */\n    _repulsion_strength?: number | undefined;\n    /**\n     * - The number of negative samples per positive sample.\n     */\n    _negative_sample_rate?: number | undefined;\n    /**\n     * - The number of training epochs.\n     */\n    _n_epochs?: number | undefined;\n    /**\n     * - The initial learning rate for the optimization.\n     */\n    _initial_alpha?: number | undefined;\n    /**\n     * - the seed for the random number generator.\n     */\n    seed?: number | undefined;\n};\nimport type { Metric } from \"../metrics/index.js\";\nimport type { EigenArgs } from \"../linear_algebra/index.js\";\nimport type { ChooseDR } from \"./SAMMON.js\";\n//# sourceMappingURL=index.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/** @import { ParametersAnnoy } from \"./index.js\" */\n/**\n * @template {number[] | Float64Array} T\n * @typedef {Object} AnnoyNode\n * @property {boolean} isLeaf - Whether this is a leaf node\n * @property {number[]} indices - Indices of points in this node (leaf) or children (internal)\n * @property {number[]} normal - Hyperplane normal vector (internal nodes only)\n * @property {number} offset - Hyperplane offset (internal nodes only)\n * @property {AnnoyNode<T> | null} left - Left child (internal nodes only)\n * @property {AnnoyNode<T> | null} right - Right child (internal nodes only)\n */\n/**\n * Annoy-style (Approximate Nearest Neighbors Oh Yeah) implementation using Random Projection Trees.\n *\n * This implementation builds multiple random projection trees where each tree randomly selects\n * two points and splits the space based on a hyperplane equidistant between them.\n *\n * Key features:\n * - Multiple random projection trees for better recall\n * - Each tree uses random hyperplanes for splitting\n * - Priority queue search for better recall\n * - Combines results from all trees\n *\n * Best suited for:\n * - High-dimensional data\n * - Approximate nearest neighbor search\n * - Large datasets\n * - When high recall is needed with approximate methods\n *\n * @class\n * @category KNN\n * @template {number[] | Float64Array} T\n * @extends KNN<T, ParametersAnnoy>\n * @see {@link https://github.com/spotify/annoy}\n * @see {@link https://erikbern.com/2015/09/24/nearest-neighbors-and-vector-models-epilogue-curse-of-dimensionality.html}\n */\nexport class Annoy<T extends number[] | Float64Array> extends KNN<T, ParametersAnnoy> {\n    /**\n     * Creates a new Annoy-style index with random projection trees.\n     *\n     * @param {T[]} elements - Elements to index\n     * @param {ParametersAnnoy} [parameters={}] - Configuration parameters\n     */\n    constructor(elements: T[], parameters?: ParametersAnnoy);\n    _metric: Metric;\n    _numTrees: number;\n    _maxPointsPerLeaf: number;\n    _seed: number;\n    _randomizer: Randomizer;\n    /**\n     * @private\n     * @type {AnnoyNode<T>[]}\n     */\n    private _trees;\n    /**\n     * Get the number of trees in the index.\n     * @returns {number}\n     */\n    get num_trees(): number;\n    /**\n     * Get the total number of nodes in all trees.\n     * @returns {number}\n     */\n    get num_nodes(): number;\n    /**\n     * @private\n     * @param {any} node\n     * @returns {number}\n     */\n    private _countNodes;\n    /**\n     * Add elements to the Annoy index.\n     * @param {T[]} elements\n     * @returns {this}\n     */\n    add(elements: T[]): this;\n    /**\n     * Build all random projection trees.\n     * @private\n     */\n    private _buildTrees;\n    /**\n     * Recursively build a random projection tree.\n     * @private\n     * @param {number[]} indices - Indices of elements to include\n     * @returns {AnnoyNode<T>}\n     */\n    private _buildTreeRecursive;\n    /**\n     * Compute distance from point to hyperplane.\n     * @private\n     * @param {T} point\n     * @param {number[]} normal\n     * @param {number} offset\n     * @returns {number} Signed distance (positive = right side, negative = left side)\n     */\n    private _distanceToHyperplane;\n    /**\n     * Search for k approximate nearest neighbors.\n     * @param {T} query\n     * @param {number} [k=5]\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search(query: T, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * Search tree using priority queue for better recall.\n     * Explores nodes in order of distance to hyperplane.\n     * @private\n     * @param {AnnoyNode<T>} node\n     * @param {T} query\n     * @param {Set<number>} candidates\n     * @param {number} maxCandidates\n     */\n    private _searchTreePriority;\n    /**\n     * @param {number} i\n     * @param {number} [k=5]\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search_by_index(i: number, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * Alias for search_by_index for backward compatibility.\n     *\n     * @param {number} i - Index of the query element\n     * @param {number} [k=5] - Number of nearest neighbors to return\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search_index(i: number, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n}\nexport type AnnoyNode<T extends number[] | Float64Array> = {\n    /**\n     * - Whether this is a leaf node\n     */\n    isLeaf: boolean;\n    /**\n     * - Indices of points in this node (leaf) or children (internal)\n     */\n    indices: number[];\n    /**\n     * - Hyperplane normal vector (internal nodes only)\n     */\n    normal: number[];\n    /**\n     * - Hyperplane offset (internal nodes only)\n     */\n    offset: number;\n    /**\n     * - Left child (internal nodes only)\n     */\n    left: AnnoyNode<T> | null;\n    /**\n     * - Right child (internal nodes only)\n     */\n    right: AnnoyNode<T> | null;\n};\nimport type { ParametersAnnoy } from \"./index.js\";\nimport { KNN } from \"./KNN.js\";\nimport type { Metric } from \"../metrics/index.js\";\nimport { Randomizer } from \"../util/index.js\";\n//# sourceMappingURL=Annoy.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/** @import { ParametersBallTree } from \"./index.js\" */\n/**\n * @template {number[] | Float64Array} T\n * @typedef {Object} ElementWithIndex\n * @property {number} index\n * @property {T} element\n */\n/**\n * Ball Tree for efficient nearest neighbor search.\n *\n * A Ball Tree is a metric tree that partitions points into a nested set of\n * hyperspheres (balls). It is particularly effective for high-dimensional\n * data and supports any valid metric.\n *\n * @class\n * @category KNN\n * @template {number[] | Float64Array} T\n * @extends KNN<T, ParametersBallTree>\n */\nexport class BallTree<T extends number[] | Float64Array> extends KNN<T, ParametersBallTree> {\n    /**\n     * Generates a BallTree with given `elements`.\n     *\n     * @param {T[]} elements - Elements which should be added to the BallTree\n     * @param {ParametersBallTree} [parameters={metric: euclidean}] Default is `{metric: euclidean}`\n     * @see {@link https://en.wikipedia.org/wiki/Ball_tree}\n     * @see {@link https://github.com/invisal/noobjs/blob/master/src/tree/BallTree.js}\n     */\n    constructor(elements: T[], parameters?: ParametersBallTree);\n    /**\n     * @private\n     * @type {BallTreeNode<T> | BallTreeLeaf<T>}\n     */\n    private _root;\n    /** @returns {Metric} */\n    get _metric(): Metric;\n    /**\n     * @private\n     * @param {ElementWithIndex<T>[]} elements\n     * @returns {BallTreeNode<T> | BallTreeLeaf<T>} Root of balltree.\n     */\n    private _construct;\n    /**\n     * @private\n     * @param {ElementWithIndex<T>[]} B\n     * @returns {number}\n     */\n    private _greatest_spread;\n    /**\n     * @param {number} i\n     * @param {number} k\n     */\n    search_by_index(i: number, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @param {T} t - Query element.\n     * @param {number} [k=5] - Number of nearest neighbors to return. Default is `5`\n     * @returns {{ element: T; index: number; distance: number }[]} - List consists of the `k` nearest neighbors.\n     */\n    search(t: T, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @private\n     * @param {T} t - Query element.\n     * @param {number} k - Number of nearest neighbors to return.\n     * @param {Heap<ElementWithIndex<T>>} Q - Heap consists of the currently found `k` nearest neighbors.\n     * @param {BallTreeNode<T> | BallTreeLeaf<T>} B\n     */\n    private _search;\n}\nexport type ElementWithIndex<T extends number[] | Float64Array> = {\n    index: number;\n    element: T;\n};\nimport type { ParametersBallTree } from \"./index.js\";\nimport { KNN } from \"./KNN.js\";\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=BallTree.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/** @import { ParametersHNSW } from \"./index.js\" */\n/**\n * @typedef {Object} Layer\n * @property {number} l_c - Layer number\n * @property {number[]} point_indices - Global indices of points in this layer\n * @property {Map<number, number[]>} edges - Global index -> array of connected global indices\n */\n/**\n * @template {number[] | Float64Array} T\n * @typedef {Object} Candidate\n * @property {T} element - The actual data point\n * @property {number} index - Global index in the dataset\n * @property {number} distance - Distance from query\n */\n/**\n * Hierarchical Navigable Small World (HNSW) graph for approximate nearest neighbor search.\n *\n * HNSW builds a multi-layer graph structure where each layer is a navigable small world graph.\n * The top layers serve as \"highways\" for fast traversal, while lower layers provide accuracy.\n * Each element is assigned to a random level, allowing logarithmic search complexity.\n *\n * Key parameters:\n * - `m`: Controls the number of connections per element (affects accuracy/memory)\n * - `ef_construction`: Controls the quality of the graph during construction (higher = better but slower)\n * - `ef`: Controls the quality of search (higher = better recall but slower)\n *\n * Based on:\n * - \"Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs\"\n *   by Malkov & Yashunin (2016)\n * - \"Approximate Nearest Neighbor Search on High Dimensional Data\"\n *   by Li et al. (2019)\n *\n * @class\n * @category KNN\n * @template {number[] | Float64Array} T\n * @extends KNN<T, ParametersHNSW>\n *\n * @example\n * import * as druid from \"@saehrimnir/druidjs\";\n *\n * const points = [[1, 2], [3, 4], [5, 6], [7, 8]];\n * const hnsw = new druid.HNSW(points, {\n *     metric: druid.euclidean,\n *     m: 16,\n *     ef_construction: 200\n * });\n *\n * const query = [2, 3];\n * const neighbors = hnsw.search(query, 2);\n * // [{ element: [1, 2], index: 0, distance: 1.41 }, ...]\n */\nexport class HNSW<T extends number[] | Float64Array> extends KNN<T, ParametersHNSW> {\n    /**\n     * Creates a new HNSW index.\n     *\n     * @param {T[]} points - Initial points to add to the index\n     * @param {ParametersHNSW} [parameters={}] - Configuration parameters\n     */\n    constructor(points: T[], parameters?: ParametersHNSW);\n    /** @type {Metric} */\n    _metric: Metric;\n    /** @type {Function} */\n    _select: Function;\n    /**\n     * @private\n     * @type {Map<number, Layer>}\n     */\n    private _graph;\n    /** @type {number} */\n    _next_index: number;\n    /** @type {number} */\n    _m: number;\n    /** @type {number} */\n    _ef_construction: number;\n    /** @type {number} */\n    _ef: number;\n    /** @type {number} */\n    _m0: number;\n    /** @type {number} */\n    _mL: number;\n    /** @type {Randomizer} */\n    _randomizer: Randomizer;\n    /** @type {number} - Current maximum layer in the graph */\n    _L: number;\n    /** @type {number[] | null} - Entry point indices for search */\n    _ep: number[] | null;\n    /**\n     * Add a single element to the index.\n     *\n     * @param {T} element - Element to add\n     * @returns {HNSW<T>} This instance for chaining\n     */\n    addOne(element: T): HNSW<T>;\n    /**\n     * Add multiple elements to the index.\n     *\n     * @param {T[]} new_elements - Elements to add\n     * @returns {HNSW<T>} This instance for chaining\n     */\n    add(new_elements: T[]): HNSW<T>;\n    /**\n     * Select neighbors using the heuristic approach.\n     *\n     * The heuristic extends candidates with their neighbors and selects\n     * points that are closer to the query than to already selected points.\n     * This maintains graph connectivity better than simple selection.\n     *\n     * @private\n     * @param {T} q - Query element\n     * @param {Candidate<T>[]} candidates - Candidate elements with distances\n     * @param {number} M - Maximum number of neighbors to return\n     * @param {number} l_c - Layer number\n     * @param {boolean} [extend_candidates=true] - Whether to extend candidates with their neighbors\n     * @param {boolean} [keep_pruned_connections=true] - Whether to add pruned connections back if needed\n     * @returns {number[]} Selected neighbor indices\n     */\n    private _select_heuristic;\n    /**\n     * Select neighbors using simple distance-based selection.\n     *\n     * Simply returns the M closest candidates to the query.\n     *\n     * @private\n     * @param {T} q - Query element\n     * @param {Candidate<T>[]} C - Candidate elements with distances\n     * @param {number} M - Maximum number of neighbors to return\n     * @returns {number[]} M nearest candidate indices\n     */\n    private _select_simple;\n    /**\n     * Search a single layer for nearest neighbors.\n     *\n     * Implements the greedy search algorithm: start from entry points,\n     * always expand the closest unvisited candidate, maintain a list\n     * of the ef closest found neighbors.\n     *\n     * @private\n     * @param {T} q - Query element\n     * @param {number[] | null} ep_indices - Entry point indices\n     * @param {number} ef - Number of nearest neighbors to find\n     * @param {number} l_c - Layer number to search\n     * @returns {Candidate<T>[]} ef nearest neighbors found with their distances\n     */\n    private _search_layer;\n    /**\n     * Fallback linear search when graph search fails\n     * @private\n     * @param {T} q - Query element\n     * @param {number} K - Number of nearest neighbors to return\n     * @returns {Candidate<T>[]}\n     */\n    private _linear_search;\n    /**\n     * Iterator for searching the HNSW graph layer by layer.\n     *\n     * Yields intermediate results at each layer for debugging or visualization.\n     *\n     * @param {T} q - Query element\n     * @param {number} K - Number of nearest neighbors to return\n     * @param {number?} [ef] - Size of dynamic candidate list\n     * @yields {{layer: number, candidates: Candidate[]}}\n     */\n    search_iter(q: T, K: number, ef?: number | null): Generator<{\n        layer: number;\n        candidates: {\n            element: T;\n            index: number;\n            distance: number;\n        }[];\n    }, void, unknown>;\n    /**\n     * Get the number of elements in the index.\n     *\n     * @returns {number} Number of elements\n     */\n    get size(): number;\n    /**\n     * Get the number of layers in the graph.\n     *\n     * @returns {number} Number of layers\n     */\n    get num_layers(): number;\n    /**\n     * Get an element by its index.\n     *\n     * @param {number} index - Element index\n     * @returns {T} The element at the given index\n     */\n    get_element(index: number): T;\n    /**\n     * Search for nearest neighbors using an element index as the query.\n     *\n     * @param {number} i - Index of the query element\n     * @param {number} [K=5] - Number of nearest neighbors to return\n     * @returns {Candidate<T>[]} K nearest neighbors\n     */\n    search_by_index(i: number, K?: number): Candidate<T>[];\n}\nexport type Layer = {\n    /**\n     * - Layer number\n     */\n    l_c: number;\n    /**\n     * - Global indices of points in this layer\n     */\n    point_indices: number[];\n    /**\n     * - Global index -> array of connected global indices\n     */\n    edges: Map<number, number[]>;\n};\nexport type Candidate<T extends number[] | Float64Array> = {\n    /**\n     * - The actual data point\n     */\n    element: T;\n    /**\n     * - Global index in the dataset\n     */\n    index: number;\n    /**\n     * - Distance from query\n     */\n    distance: number;\n};\nimport type { ParametersHNSW } from \"./index.js\";\nimport { KNN } from \"./KNN.js\";\nimport type { Metric } from \"../metrics/index.js\";\nimport { Randomizer } from \"../util/index.js\";\n//# sourceMappingURL=HNSW.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/** @import { ParametersKDTree } from \"./index.js\" */\n/**\n * @template {number[] | Float64Array} T\n * @typedef {Object} ElementWithIndex\n * @property {number} index\n * @property {T} element\n */\n/**\n * KD-Tree (K-dimensional Tree) for efficient nearest neighbor search.\n *\n * KD-Trees partition k-dimensional space by recursively splitting along coordinate axes.\n * At each level, the tree splits points based on the median of the coordinate with the largest spread.\n * This creates a balanced binary tree structure that enables efficient O(log n) search on average.\n *\n * Best suited for:\n * - Low to moderate dimensional data (d < 20-30)\n * - When exact nearest neighbors are needed\n * - When dimensionality is not too high\n *\n * Performance degrades in high dimensions (curse of dimensionality) where approximate\n * methods like HNSW or LSH become more effective.\n *\n * @class\n * @category KNN\n * @template {number[] | Float64Array} T\n * @extends KNN<T, ParametersKDTree>\n * @see {@link https://en.wikipedia.org/wiki/K-d_tree}\n */\nexport class KDTree<T extends number[] | Float64Array> extends KNN<T, ParametersKDTree> {\n    /**\n     * Generates a KD-Tree with given `elements`.\n     *\n     * @param {T[]} elements - Elements which should be added to the KD-Tree\n     * @param {ParametersKDTree} [parameters={metric: euclidean}] Default is `{metric: euclidean}`\n     */\n    constructor(elements: T[], parameters?: ParametersKDTree);\n    /**\n     * @private\n     * @type {KDTreeNode<T> | KDTreeLeaf<T> | null}\n     */\n    private _root;\n    /** @returns {Metric} */\n    get _metric(): Metric;\n    /**\n     * @private\n     * @param {ElementWithIndex<T>[]} elements\n     * @param {number} depth - Current depth in the tree (determines splitting axis)\n     * @returns {KDTreeNode<T> | KDTreeLeaf<T> | null} Root of KD-Tree.\n     */\n    private _construct;\n    /**\n     * @param {number} i\n     * @param {number} k\n     */\n    search_by_index(i: number, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @param {T} t - Query element.\n     * @param {number} [k=5] - Number of nearest neighbors to return. Default is `5`\n     * @returns {{ element: T; index: number; distance: number }[]} - List consists of the `k` nearest neighbors.\n     */\n    search(t: T, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @private\n     * @param {T} target - Query element.\n     * @param {number} k - Number of nearest neighbors to return.\n     * @param {KDTreeNode<T> | KDTreeLeaf<T> | null} node - Current node.\n     * @param {Heap<{ point: ElementWithIndex<T>; distance: number }>} best - Heap of k best found so far.\n     */\n    private _search_recursive;\n}\nexport type ElementWithIndex<T extends number[] | Float64Array> = {\n    index: number;\n    element: T;\n};\nimport type { ParametersKDTree } from \"./index.js\";\nimport { KNN } from \"./KNN.js\";\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=KDTree.d.ts.map","/** @import { Metric } from \"../metrics/index.js\" */\n/** @import { ParametersLSH } from \"./index.js\" */\n/**\n * Locality Sensitive Hashing (LSH) for approximate nearest neighbor search.\n *\n * LSH uses hash functions that map similar items to the same buckets with high probability.\n * This implementation uses Random Projection hashing (SimHash-style) which works well for\n * cosine similarity and Euclidean distance.\n *\n * Key concepts:\n * - Multiple hash tables increase recall probability\n * - Each hash function projects data onto random hyperplanes\n * - Points on the same side of hyperplanes are hashed together\n * - Combines results from all tables for better accuracy\n *\n * Best suited for:\n * - High-dimensional data where exact methods fail\n * - Approximate nearest neighbor needs\n * - Large datasets where linear scan is too slow\n * - When some false positives/negatives are acceptable\n *\n * @class\n * @category KNN\n * @template {number[] | Float64Array} T\n * @extends KNN<T, ParametersLSH>\n * @see {@link https://en.wikipedia.org/wiki/Locality-sensitive_hashing}\n */\nexport class LSH<T extends number[] | Float64Array> extends KNN<T, ParametersLSH> {\n    /**\n     * Creates a new LSH index.\n     *\n     * @param {T[]} elements - Elements to index\n     * @param {ParametersLSH} [parameters={}] - Configuration parameters\n     */\n    constructor(elements: T[], parameters?: ParametersLSH);\n    _metric: Metric;\n    _numHashTables: number;\n    _numHashFunctions: number;\n    _seed: number;\n    _randomizer: Randomizer;\n    /** @type {Map<string, number[]>[]} */\n    _hashTables: Map<string, number[]>[];\n    /** @type {Float64Array[][]} */\n    _projections: Float64Array[][];\n    /** @type {number[][]} */\n    _offsets: number[][];\n    /** @type {number} */\n    _dim: number;\n    /**\n     * Initialize random projection vectors for all hash tables.\n     * @private\n     */\n    private _initializeHashFunctions;\n    /**\n     * Compute hash signature for an element using random projections.\n     * @private\n     * @param {T} element\n     * @param {number} tableIndex\n     * @returns {string} Hash signature\n     */\n    private _computeHash;\n    /**\n     * Add elements to the LSH index.\n     * @param {T[]} elements\n     * @returns {this}\n     */\n    add(elements: T[]): this;\n    /**\n     * Search for k approximate nearest neighbors.\n     * @param {T} query\n     * @param {number} [k=5]\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search(query: T, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @param {number} i\n     * @param {number} [k=5]\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search_by_index(i: number, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n}\nimport type { ParametersLSH } from \"./index.js\";\nimport { KNN } from \"./KNN.js\";\nimport type { Metric } from \"../metrics/index.js\";\nimport { Randomizer } from \"../util/index.js\";\n//# sourceMappingURL=LSH.d.ts.map","/** @import { ParametersNaiveKNN } from \"./index.js\" */\n/**\n * Naive KNN implementation using a distance matrix.\n *\n * This implementation pre-computes the entire distance matrix and performs\n * an exhaustive search. Best suited for small datasets or when a distance\n * matrix is already available.\n *\n * @template {number[] | Float64Array} T\n * @category KNN\n * @class\n * @extends KNN<T, ParametersNaiveKNN>\n */\nexport class NaiveKNN<T extends number[] | Float64Array> extends KNN<T, ParametersNaiveKNN> {\n    /**\n     * Generates a KNN list with given `elements`.\n     *\n     * @param {T[]} elements - Elements which should be added to the KNN list\n     * @param {ParametersNaiveKNN} parameters\n     */\n    constructor(elements: T[], parameters?: ParametersNaiveKNN);\n    _D: Matrix;\n    /** @type {Heap<{ value: number; index: number }>[]} */\n    KNN: Heap<{\n        value: number;\n        index: number;\n    }>[];\n    /**\n     * @param {number} i\n     * @param {number} k\n     */\n    search_by_index(i: number, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @param {T} t - Query element.\n     * @param {number} [k=5] - Number of nearest neighbors to return. Default is `5`\n     * @returns {{ element: T; index: number; distance: number }[]} - List consists of the `k` nearest neighbors.\n     */\n    search(t: T, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n}\nimport type { ParametersNaiveKNN } from \"./index.js\";\nimport { KNN } from \"./KNN.js\";\nimport { Matrix } from \"../matrix/index.js\";\nimport { Heap } from \"../datastructure/index.js\";\n//# sourceMappingURL=NaiveKNN.d.ts.map","/** @import {ParametersNNDescent} from \"./index.js\" */\n/**\n *\n * @template {number[] | Float64Array} T\n * @typedef {Object} NNDescentElement\n * @property {T} value\n * @property {number} index\n * @property {boolean} flag\n */\n/**\n * @template {number[] | Float64Array} T\n * @typedef {Object} NNDescentNeighbor\n * @property {T} value\n * @property {number} index\n * @property {number} distance\n * @property {boolean} [flag]\n */\n/**\n * NN-Descent\n *\n * An efficient graph-based approximate nearest neighbor search algorithm.\n * It works by iteratively improving a neighbor graph using the fact that\n * \"neighbors of neighbors are likely to be neighbors\".\n *\n * @class\n * @category KNN\n * @template {number[] | Float64Array} T\n * @extends KNN<T, ParametersNNDescent>\n * @see {@link http://www.cs.princeton.edu/cass/papers/www11.pdf|NN-Descent Paper}\n */\nexport class NNDescent<T extends number[] | Float64Array> extends KNN<T, ParametersNNDescent> {\n    /**\n     * @param {T[]} elements - Called V in paper.\n     * @param {Partial<ParametersNNDescent>} parameters\n     * @see {@link http://www.cs.princeton.edu/cass/papers/www11.pdf}\n     */\n    constructor(elements: T[], parameters?: Partial<ParametersNNDescent>);\n    /**\n     * @private\n     * @type {KNNHeap<T>[]}\n     */\n    private _B;\n    /**\n     * @private\n     * @type {NNDescentNeighbor<T>[][]}\n     */\n    private nn;\n    _N: number;\n    _randomizer: Randomizer;\n    _sample_size: number;\n    _nndescent_elements: {\n        value: T;\n        index: number;\n        flag: boolean;\n    }[];\n    /**\n     * Samples Array A with sample size.\n     *\n     * @private\n     * @template U\n     * @param {U[]} A\n     * @returns {U[]}\n     */\n    private _sample;\n    /**\n     * @private\n     * @param {KNNHeap<T>} B\n     * @param {NNDescentNeighbor<T>} u\n     * @returns {number}\n     */\n    private _update;\n    /**\n     * @private\n     * @param {(KNNHeap<T> | null)[]} B\n     * @returns {NNDescentNeighbor<T>[][]}\n     */\n    private _reverse;\n    /**\n     * @param {T[]} elements\n     * @returns {this}\n     */\n    add(elements: T[]): this;\n    /**\n     * @param {T} x\n     * @param {number} [k=5] Default is `5`\n     * @returns {{ element: T, index: number; distance: number }[]}\n     */\n    search(x: T, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n    /**\n     * @param {number} i\n     * @param {number} [k=5] Default is `5`\n     * @returns {{ element: T; index: number; distance: number }[]}\n     */\n    search_by_index(i: number, k?: number): {\n        element: T;\n        index: number;\n        distance: number;\n    }[];\n}\nexport type NNDescentElement<T extends number[] | Float64Array> = {\n    value: T;\n    index: number;\n    flag: boolean;\n};\nexport type NNDescentNeighbor<T extends number[] | Float64Array> = {\n    value: T;\n    index: number;\n    distance: number;\n    flag?: boolean | undefined;\n};\nexport type HeapEntry<U extends number[] | Float64Array> = {\n    element: NNDescentNeighbor<U>;\n    value: number;\n};\nimport type { ParametersNNDescent } from \"./index.js\";\nimport { KNN } from \"./KNN.js\";\nimport { Randomizer } from \"../util/index.js\";\n//# sourceMappingURL=NNDescent.d.ts.map","export { Annoy } from \"./Annoy.js\";\nexport { BallTree } from \"./BallTree.js\";\nexport { HNSW } from \"./HNSW.js\";\nexport { KDTree } from \"./KDTree.js\";\nexport { LSH } from \"./LSH.js\";\nexport { NaiveKNN } from \"./NaiveKNN.js\";\nexport { NNDescent } from \"./NNDescent.js\";\nexport type ParametersAnnoy = {\n    /**\n     * - Metric to use: (a, b) => distance. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * - Number of random projection trees to build. Default is `10`\n     */\n    numTrees: number;\n    /**\n     * - Maximum points per leaf node. Default is `10`\n     */\n    maxPointsPerLeaf: number;\n    /**\n     * - Seed for random number generator. Default is `1212`\n     */\n    seed: number;\n};\nexport type ParametersBallTree = {\n    metric: Metric;\n    seed: number;\n};\nexport type ParametersHNSW = {\n    /**\n     * - Metric to use: (a, b) => distance. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * - Use heuristics or naive selection. Default is `true`\n     */\n    heuristic: boolean;\n    /**\n     * - Max number of connections per element (excluding ground layer). Default is `16`\n     */\n    m: number;\n    /**\n     * - Size of candidate list during construction. Default is `200`\n     */\n    ef_construction: number;\n    /**\n     * - Max number of connections for ground layer (layer 0). Default is `2 * m`\n     */\n    m0: number | null;\n    /**\n     * - Normalization factor for level generation. Default is `1 / Math.log(m)`\n     */\n    mL: number | null;\n    /**\n     * - Seed for random number generator. Default is `1212`\n     */\n    seed: number;\n    /**\n     * - Size of candidate list during search. Default is `50`\n     */\n    ef: number;\n};\nexport type ParametersKDTree = {\n    /**\n     * - Metric to use: (a, b) => distance. Default is `euclidean`\n     */\n    metric: Metric;\n    seed: number;\n};\nexport type ParametersLSH = {\n    /**\n     * - Metric to use: (a, b) => distance. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * - Number of hash tables. Default is `10`\n     */\n    numHashTables: number;\n    /**\n     * - Number of hash functions per table. Default is `10`\n     */\n    numHashFunctions: number;\n    /**\n     * - Seed for random number generator. Default is `1212`\n     */\n    seed: number;\n};\nexport type ParametersNaiveKNN = {\n    /**\n     * Is either precomputed or a function to use: (a, b) => distance\n     */\n    metric?: Metric | \"precomputed\" | undefined;\n    seed?: number | undefined;\n};\nexport type ParametersNNDescent = {\n    /**\n     * - Called sigma in paper. Default is `euclidean`\n     */\n    metric: Metric;\n    /**\n     * =10 - Number of samples. Default is `10`\n     */\n    samples: number;\n    /**\n     * = .8 - Sample rate. Default is `.8`\n     */\n    rho: number;\n    /**\n     * = 0.0001 - Precision parameter. Default is `0.0001`\n     */\n    delta: number;\n    /**\n     * = 1212 - Seed for the random number generator. Default is `1212`\n     */\n    seed: number;\n};\nimport type { Metric } from \"../metrics/index.js\";\n//# sourceMappingURL=index.d.ts.map","/**\n * Numerical stable summation with the Kahan summation algorithm.\n *\n * @category Numerical\n * @param {number[] | Float64Array} summands - Array of values to sum up.\n * @returns {number} The sum.\n * @see {@link https://en.wikipedia.org/wiki/Kahan_summation_algorithm}\n */\nexport function kahan_sum(summands: number[] | Float64Array): number;\n//# sourceMappingURL=kahan_sum.d.ts.map","/**\n * Numerical stable summation with the Neumair summation algorithm.\n *\n * @category Numerical\n * @param {number[] | Float64Array} summands - Array of values to sum up.\n * @returns {number} The sum.\n * @see {@link https://en.wikipedia.org/wiki/Kahan_summation_algorithm#Further_enhancements}\n */\nexport function neumair_sum(summands: number[] | Float64Array): number;\n//# sourceMappingURL=neumair_sum.d.ts.map","/**\n * @template {Float64Array | number[]} T\n * @category Optimization\n * @param {(d: T) => number} f\n * @param {T} x0\n * @param {number} [max_iter=300] Default is `300`\n * @returns {T}\n * @see http://optimization-js.github.io/optimization-js/optimization.js.html#line438\n */\nexport function powell<T extends Float64Array | number[]>(f: (d: T) => number, x0: T, max_iter?: number): T;\n//# sourceMappingURL=powell.d.ts.map","export * from \"./clustering/index.js\";\nexport * from \"./datastructure/index.js\";\nexport * from \"./dimred/index.js\";\nexport * from \"./knn/index.js\";\nexport * from \"./linear_algebra/index.js\";\nexport * from \"./matrix/index.js\";\nexport * from \"./metrics/index.js\";\nexport * from \"./numerical/index.js\";\nexport * from \"./optimization/index.js\";\nexport * from \"./util/index.js\";\nexport type InputType = Matrix | Float64Array[] | number[][];\nexport const version: string;\nimport type { Matrix } from \"./matrix/index.js\";\n//# sourceMappingURL=index.d.ts.map"],"names":["___knn_KNN_js.KNN","___matrix_index_js.Matrix"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,WAAA,eAAA,YAAA,gBAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,QAAA,eAAA,YAAA,gBAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,SAAA,eAAA,YAAA,gBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,MAAA,eAAA,YAAA,gBAAA,YAAA;;ACbP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,SAAA,eAAA,YAAA,gBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACO,iBAAA,iBAAA,eAAA,YAAA,gBAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,eAAA,eAAA,YAAA,gBAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,OAAA,eAAA,YAAA,gBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,SAAA,eAAA,YAAA,gBAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,OAAA,eAAA,YAAA,gBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,SAAA,eAAA,YAAA,gBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACO,iBAAA,cAAA,eAAA,YAAA,gBAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,WAAA,eAAA,YAAA,gBAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,IAAA,eAAA,YAAA,gBAAA,YAAA;;ACMA,KAAA,MAAA,kBAAA,YAAA,gBAAA,YAAA;;ACdP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,eAAA,IAAA,MAAA,GAAA,YAAA,0BAAA,MAAA,GAAA,MAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,mBAAA,IAAA,MAAA,sBAAA,MAAA;AACP;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,QAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,GAAA,SAAA,QAAA;;ACPP;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,GAAA,SAAA,QAAA;;ACPP;AACA;AACA;AACA;AACO,cAAA,UAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7DA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAA,MAAA,GAAA,YAAA,kBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,YAAA,GAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAA,YAAA,wBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAA,MAAA,KAAA,MAAA,eAAA,UAAA,wBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAA,MAAA;AACA,WAAA,MAAA;AACA,WAAA,MAAA;AACA,UAAA,MAAA,GAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,MAAA;AACA,WAAA,MAAA;AACA,WAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA,MAAA;AACA,WAAA,YAAA;AACA,eAAA,YAAA;AACA,WAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,4DAAA,YAAA,GAAA,YAAA;AACA;AACA;AACA;AACA;AACA,kDAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAA,QAAA;AACA;AACA;AACA,uCAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAA,SAAA,CAAA,YAAA,CAAA,eAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAA,MAAA,cAAA,YAAA,GAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAA,MAAA,cAAA,YAAA,GAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAA,MAAA,cAAA,YAAA,GAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA,GAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAA,MAAA,8CAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAA,MAAA,GAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uGAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,YAAA,wCAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,YAAA,wCAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA,MAAA,cAAA,YAAA,iDAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAA,MAAA,GAAA,YAAA;AACA;AACA,QAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA,MAAA,GAAA,YAAA;AACA;AACA,QAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,MAAA,GAAA,YAAA;AACA;AACA,QAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,MAAA,GAAA,YAAA;AACA;AACA,QAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAA,QAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,KAAA,MAAA,CAAA,QAAA,KAAA,SAAA,CAAA,YAAA,CAAA,eAAA;AACA;AACO,KAAA,QAAA;;ACjdP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,IAAA,IAAA,MAAA,cAAA,YAAA,WAAA,MAAA;;ACTP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,SAAA,eAAA,YAAA,WAAA,MAAA,cAAA,YAAA;;ACTP;AACA;AACA;AACA;AACA;AACO,cAAA,UAAA;AACP;AACA;AACA;AACA;AACA;AACA,wBAAA,SAAA;AACA;AACA,aAAA,SAAA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,IAAA,SAAA,UAAA,CAAA,cAAA;AACP;AACA;AACA;AACA;AACA,wBAAA,SAAA,eAAA,OAAA,CAAA,cAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,sBAAA,SAAA,UAAA,CAAA,gCAAA;AACP;AACA;AACA;AACA;AACA,wBAAA,SAAA,eAAA,OAAA,CAAA,gCAAA;AACA;AACA,UAAA,OAAA;AACA;AACA,YAAA,YAAA,CAAA,WAAA;AACA,sBAAA,MAAA;AACA;AACA,aAAA,WAAA,CAAA,WAAA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;AACA,cAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAA,OAAA,gBAAA,OAAA,iCAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,OAAA;AACA;AACA,UAAA,OAAA;AACA,WAAA,OAAA;AACA;AACA;AACA,cAAA,YAAA,CAAA,eAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAAA,OAAA,SAAA,OAAA,GAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,cAAA,OAAA;AACA;AACA;AACA;AACA;AACA,mBAAA,OAAA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,SAAA,UAAA,CAAA,gBAAA;AACP;AACA;AACA;AACA;AACA,wBAAA,SAAA,eAAA,OAAA,CAAA,gBAAA;AACA;AACA,iBAAA,UAAA;AACA;AACA;AACA,wBAAA,YAAA,CAAA,eAAA;AACA;AACA;AACA;AACA,qBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,QAAA,SAAA,UAAA,CAAA,kBAAA;AACP;AACA;AACA;AACA;AACA;AACA,wBAAA,SAAA,eAAA,OAAA,CAAA,kBAAA;AACA,QAAA,YAAA,CAAA,eAAA;AACA;AACA,sBAAA,MAAA;AACA,iBAAA,UAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,cAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAAA,YAAA,eAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,SAAA,SAAA,UAAA,CAAA,mBAAA;AACP;AACA;AACA;AACA;AACA;AACA,wBAAA,SAAA,eAAA,OAAA,CAAA,mBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,SAAA,UAAA,CAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAA,SAAA,eAAA,OAAA,CAAA,gBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,SAAA,UAAA,CAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAA,SAAA,eAAA,OAAA,CAAA,gBAAA;AACA,iBAAA,UAAA;AACA;AACA,kBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7FO,KAAA,gCAAA;AACP;AACA,YAAA,MAAA;AACA;AACO,KAAA,gBAAA;AACP;AACA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAA,YAAA,CAAA,eAAA;AACA;AACO,KAAA,kBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACO,KAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,mBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,WAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAA,GAAA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,IAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oGAAA,UAAA,GAAA,IAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6GAAA,UAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,UAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAA,IAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvHO,KAAA,UAAA;;ACFP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,EAAA,WAAA,SAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAA,SAAA,2CAAA,SAAA,CAAA,SAAA,EAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAA,SAAA,2CAAA,OAAA,CAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,UAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAA,MAAA;AACA;AACA,OAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAA,OAAA;AACA;;AC5IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,OAAA,WAAA,SAAA,UAAA,EAAA,IAAA,iBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,iBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,iBAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,sBAAA,OAAA,CAAA,iBAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAA,OAAA,CAAA,iBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,WAAA,SAAA,UAAA,EAAA,IAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,gBAAA;AACA,cAAA,gBAAA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,GAAA,WAAA,SAAA,UAAA,EAAA,IAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA;AACA;AACA,kCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA;AACA;AACA,kCAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAA,OAAA,CAAA,aAAA;AACA,wBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,GAAA,WAAA,SAAA,UAAA,EAAA,IAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,aAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,sBAAA,OAAA,CAAA,aAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,GAAA,WAAA,SAAA,UAAA,EAAA,IAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA,YAAA,GAAA;AACA,QAAA,MAAA;AACA,QAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,IAAA,WAAA,SAAA,UAAA,EAAA,IAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,cAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,cAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,sBAAA,OAAA,CAAA,cAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAA,OAAA,CAAA,cAAA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,GAAA,WAAA,SAAA,UAAA,EAAA,IAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAA,MAAA;AACA;AACA;AACA;;AC5DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,GAAA,WAAA,SAAA,UAAA,EAAA,IAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,SAAA,sBAAA,OAAA,CAAA,aAAA,IAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,aAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAAA,MAAA;AACA,OAAA,MAAA;AACA;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,WAAA,SAAA,UAAA,EAAA,IAAA,gBAAA,CAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,CAAA,aAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,CAAA,aAAA,KAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,CAAA,aAAA,KAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,gBAAA,CAAA,aAAA;AACA;AACA,qBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,MAAA,4BAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAA,SAAA;AACA,aAAA,MAAA;AACA;AACO,KAAA,aAAA;AACA,KAAA,QAAA;AACP,SAAA,aAAA;AACA,SAAA,aAAA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,WAAA,SAAA,UAAA,EAAA,IAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,gBAAA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,WAAA,SAAA,UAAA,EAAA,IAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,gBAAA;AACA;AACA,yBAAA,YAAA,CAAA,eAAA,QAAA,YAAA;AACA,mBAAA,YAAA,CAAA,eAAA,MAAA,YAAA,CAAA,eAAA,mBAAA,YAAA;AACA,iBAAA,YAAA,CAAA,eAAA,MAAA,YAAA,CAAA,eAAA,MAAA,YAAA;AACA,gBAAA,YAAA,CAAA,eAAA,iBAAA,YAAA;AACA;AACA;AACA;AACA,gBAAA,MAAA;AACA,YAAA,MAAA;AACA;AACA;AACA,2CAAA,MAAA;AACA;AACA,wDAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAA,MAAA,SAAA,MAAA,gDAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAAA,YAAA,CAAA,eAAA,MAAA,YAAA,CAAA,eAAA,MAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAA,YAAA,CAAA,eAAA,QAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,2BAAA,YAAA,CAAA,eAAA,iBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA,8BAAA,YAAA,CAAA,eAAA,MAAA,YAAA,CAAA,eAAA,mBAAA,YAAA;AACA;;ACjKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,OAAA,WAAA,SAAA,UAAA,EAAA,IAAA,iBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,iBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,sBAAA,OAAA,CAAA,iBAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,sBAAA,OAAA,CAAA,iBAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAA,OAAA,CAAA,iBAAA;AACA,sBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAA,WAAA,CAAA,YAAA,CAAA,eAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,SAAA;AACA;;AC3IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,GAAA,sBAAA,YAAA,eAAA,MAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,WAAA,SAAA,UAAA,EAAA,IAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,gBAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,gBAAA;AACA;AACA;AACA;AACA;AACA,eAAA,MAAA,eAAoCA,GAAuB,YAAA,YAAA;AAC3D;AACA;AACA;AACA,SAAA,GAAA,YAAA,YAAA,CAAA,eAAA;AACA,cAAA,MAAA;AACA,aAAA,YAAA,CAAA,WAAA;AACA;AACA;AACA,SAAA,MAAA;AACA,UAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA,MAAA;AACA,iBAAA,YAAA,CAAA,WAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA,cAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,IAAA,WAAA,SAAA,UAAA,EAAA,IAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,cAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,cAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,cAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,cAAA;AACA;AACA;AACA,YAAA,MAAA;AACA,YAAA,MAAA;AACA,QAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,IAAA,WAAA,SAAA,UAAA,EAAA,IAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,cAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAA,SAAA,uBAAA,OAAA,CAAA,cAAA,IAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAA,SAAA,uBAAA,OAAA,CAAA,cAAA,IAAA,OAAA;AACA;AACA;AACA;AACA;AACA,mCAAA,OAAA,CAAA,cAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAA,IAAA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA,wBAAA,YAAA,CAAA,eAAA;AACA,iCAAA,YAAA,CAAA,WAAA;AACA,2BAAA,YAAA,CAAA,WAAA;AACA,oCAAA,YAAA,CAAA,WAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,aAAA,eAAA,YAAA,gBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,EAAA,IAAA,MAAA;AACP,OAAA,MAAA;AACA,OAAA,MAAA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,cAAA,IAAA,MAAA;AACP,OAAA,MAAA;AACA,OAAA,MAAA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,2BAAA,IAAA,MAAA,kDAAA,SAAA;AACP,iBAAA,YAAA;AACA,kBAAA,YAAA;AACA;;ACXO,KAAA,eAAA,OAA2BC,MAA4B;AAC9D,OAAOA,MAA4B;AACnC,OAAOA,MAA4B;AACnC;AACO,KAAA,SAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAA,UAAA;AACA;AACA;AACA;AACA,SAAA,eAAA;AACA;AACA;AACA;AACA;AACA;;ACVO,KAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,iBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,OAAA,CAAA,SAAA;AACA;AACO,KAAA,aAAA;AACP;AACA;AACA;AACA,oBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,OAAA,CAAA,SAAA;AACA;AACO,KAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,OAAA,CAAA,SAAA;AACA;AACO,KAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,OAAA,CAAA,SAAA;AACA;AACO,KAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,OAAA,CAAA,SAAA;AACA;AACO,KAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAA,OAAA,CAAA,SAAA;AACA;AACO,KAAA,gBAAA,iBAAA,QAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAA,QAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,gBAAA;AACP;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,iBAAA;AACP;AACA;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5VA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,KAAA,sBAAA,YAAA,UAAA,GAAA,IAAA,eAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,eAAA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA,iBAAA,UAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,QAAA,sBAAA,YAAA,UAAA,GAAA,IAAA,kBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,kBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,IAAA,sBAAA,YAAA,UAAA,GAAA,IAAA,cAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,0CAAA,cAAA;AACA;AACA,aAAA,MAAA;AACA;AACA,aAAA,QAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,UAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAA,IAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAAA,IAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAA,SAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,SAAA;AACA;AAeO,KAAA,SAAA,sBAAA,YAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,MAAA,sBAAA,YAAA,UAAA,GAAA,IAAA,gBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,gBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,GAAA,sBAAA,YAAA,UAAA,GAAA,IAAA,aAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,aAAA;AACA,aAAA,MAAA;AACA;AACA;AACA;AACA,iBAAA,UAAA;AACA;AACA,iBAAA,GAAA;AACA;AACA,kBAAA,YAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,QAAA,sBAAA,YAAA,UAAA,GAAA,IAAA,kBAAA;AACP;AACA;AACA;AACA;AACA;AACA;AACA,4CAAA,kBAAA;AACA,QAAA,MAAA;AACA;AACA,SAAA,IAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,cAAA,SAAA,sBAAA,YAAA,UAAA,GAAA,IAAA,mBAAA;AACP;AACA;AACA;AACA;AACA;AACA,4CAAA,OAAA,CAAA,mBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA,UAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/FO,KAAA,eAAA;AACP;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,kBAAA;AACP,YAAA,MAAA;AACA;AACA;AACO,KAAA,cAAA;AACP;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,gBAAA;AACP;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACO,KAAA,aAAA;AACP;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,KAAA,kBAAA;AACP;AACA;AACA;AACA,aAAA,MAAA;AACA;AACA;AACO,KAAA,mBAAA;AACP;AACA;AACA;AACA,YAAA,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,SAAA,sBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,WAAA,sBAAA,YAAA;;ACRP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,iBAAA,MAAA,WAAA,YAAA;;ACCA,KAAA,SAAA,GAAA,MAAA,GAAA,YAAA;AACA,cAAA,OAAA;;;;"}