umap-web 0.2.0

package/dist/worker.js

@@ -0,0 +1,1095 @@
+//#region src/knn/heap.ts
+function makeHeap(n, size) {
+	return {
+		indices: new Int32Array(n * size).fill(-1),
+		distances: new Float32Array(n * size).fill(Infinity),
+		flags: new Uint8Array(n * size),
+		n,
+		size
+	};
+}
+/**
+* checked_flagged_heap_push (utils.py:471-533). Operates on one row given by base
+* offset. Rejects p >= root (ties dropped) and duplicates. Returns 1 if pushed.
+*/
+function checkedFlaggedHeapPush(heap, row, p, n, f) {
+	const size = heap.size;
+	const base = row * size;
+	const priorities = heap.distances;
+	const indices = heap.indices;
+	const flags = heap.flags;
+	if (p >= priorities[base]) return 0;
+	for (let i$1 = 0; i$1 < size; i$1++) if (indices[base + i$1] === n) return 0;
+	let i = 0;
+	for (;;) {
+		const ic1 = 2 * i + 1;
+		const ic2 = ic1 + 1;
+		let iSwap;
+		if (ic1 >= size) break;
+		if (ic2 >= size) if (priorities[base + ic1] > p) iSwap = ic1;
+		else break;
+		else if (priorities[base + ic1] >= priorities[base + ic2]) if (p < priorities[base + ic1]) iSwap = ic1;
+		else break;
+		else if (p < priorities[base + ic2]) iSwap = ic2;
+		else break;
+		priorities[base + i] = priorities[base + iSwap];
+		indices[base + i] = indices[base + iSwap];
+		flags[base + i] = flags[base + iSwap];
+		i = iSwap;
+	}
+	priorities[base + i] = p;
+	indices[base + i] = n;
+	flags[base + i] = f;
+	return 1;
+}
+
+//#endregion
+//#region src/types.ts
+var UmapError = class extends Error {
+	name = "UmapError";
+};
+var UmapValidationError = class extends UmapError {
+	name = "UmapValidationError";
+};
+
+//#endregion
+//#region src/metrics.ts
+function euclidean(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const d = x[i] - y[i];
+		result += d * d;
+	}
+	return Math.sqrt(result);
+}
+/** Squared euclidean — used internally by the optimizer (rdist). */
+function sqeuclidean(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const d = x[i] - y[i];
+		result += d * d;
+	}
+	return result;
+}
+function standardisedEuclidean(x, y, sigma) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const d = x[i] - y[i];
+		result += d * d / sigma[i];
+	}
+	return Math.sqrt(result);
+}
+function manhattan(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) result += Math.abs(x[i] - y[i]);
+	return result;
+}
+function chebyshev(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const v = Math.abs(x[i] - y[i]);
+		if (v > result) result = v;
+	}
+	return result;
+}
+function minkowski(x, y, p) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) result += Math.abs(x[i] - y[i]) ** p;
+	return result ** (1 / p);
+}
+function weightedMinkowski(x, y, w, p) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) result += w[i] * Math.abs(x[i] - y[i]) ** p;
+	return result ** (1 / p);
+}
+function mahalanobis(x, y, vinv) {
+	const n = x.length;
+	let result = 0;
+	const diff = new Float64Array(n);
+	for (let i = 0; i < n; i++) diff[i] = x[i] - y[i];
+	for (let i = 0; i < n; i++) {
+		let tmp = 0;
+		for (let j = 0; j < n; j++) tmp += vinv[i * n + j] * diff[j];
+		result += tmp * diff[i];
+	}
+	return Math.sqrt(result);
+}
+function hamming(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) result += 1;
+	return result / x.length;
+}
+function canberra(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const denominator = Math.abs(x[i]) + Math.abs(y[i]);
+		if (denominator > 0) result += Math.abs(x[i] - y[i]) / denominator;
+	}
+	return result;
+}
+function brayCurtis(x, y) {
+	let numerator = 0;
+	let denominator = 0;
+	for (let i = 0; i < x.length; i++) {
+		numerator += Math.abs(x[i] - y[i]);
+		denominator += Math.abs(x[i] + y[i]);
+	}
+	return denominator > 0 ? numerator / denominator : 0;
+}
+function jaccard(x, y) {
+	let numNonZero = 0;
+	let numEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numNonZero += xt || yt ? 1 : 0;
+		numEqual += xt && yt ? 1 : 0;
+	}
+	return numNonZero === 0 ? 0 : (numNonZero - numEqual) / numNonZero;
+}
+function matching(x, y) {
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) if (x[i] !== 0 !== (y[i] !== 0)) numNotEqual += 1;
+	return numNotEqual / x.length;
+}
+function dice(x, y) {
+	let numTrueTrue = 0;
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		numNotEqual += xt !== yt ? 1 : 0;
+	}
+	return numNotEqual === 0 ? 0 : numNotEqual / (2 * numTrueTrue + numNotEqual);
+}
+function kulsinski(x, y) {
+	let numTrueTrue = 0;
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		numNotEqual += xt !== yt ? 1 : 0;
+	}
+	return numNotEqual === 0 ? 0 : (numNotEqual - numTrueTrue + x.length) / (numNotEqual + x.length);
+}
+function rogersTanimoto(x, y) {
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) if (x[i] !== 0 !== (y[i] !== 0)) numNotEqual += 1;
+	return 2 * numNotEqual / (x.length + numNotEqual);
+}
+function russellrao(x, y) {
+	let numTrueTrue = 0;
+	let xNonZero = 0;
+	let yNonZero = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		xNonZero += xt ? 1 : 0;
+		yNonZero += yt ? 1 : 0;
+	}
+	if (numTrueTrue === xNonZero && numTrueTrue === yNonZero) return 0;
+	return (x.length - numTrueTrue) / x.length;
+}
+function sokalMichener(x, y) {
+	return rogersTanimoto(x, y);
+}
+function sokalSneath(x, y) {
+	let numTrueTrue = 0;
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		numNotEqual += xt !== yt ? 1 : 0;
+	}
+	return numNotEqual === 0 ? 0 : numNotEqual / (.5 * numTrueTrue + numNotEqual);
+}
+function yule(x, y) {
+	let tt = 0;
+	let tf = 0;
+	let ft = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		tt += xt && yt ? 1 : 0;
+		tf += xt && !yt ? 1 : 0;
+		ft += !xt && yt ? 1 : 0;
+	}
+	const ff = x.length - tt - tf - ft;
+	if (tf === 0 || ft === 0) return 0;
+	return 2 * tf * ft / (tt * ff + tf * ft);
+}
+function cosine(x, y) {
+	let result = 0;
+	let normX = 0;
+	let normY = 0;
+	for (let i = 0; i < x.length; i++) {
+		result += x[i] * y[i];
+		normX += x[i] * x[i];
+		normY += y[i] * y[i];
+	}
+	if (normX === 0 && normY === 0) return 0;
+	if (normX === 0 || normY === 0) return 1;
+	return 1 - result / Math.sqrt(normX * normY);
+}
+function correlation(x, y) {
+	let muX = 0;
+	let muY = 0;
+	let normX = 0;
+	let normY = 0;
+	let dot = 0;
+	const n = x.length;
+	for (let i = 0; i < n; i++) {
+		muX += x[i];
+		muY += y[i];
+	}
+	muX /= n;
+	muY /= n;
+	for (let i = 0; i < n; i++) {
+		const sx = x[i] - muX;
+		const sy = y[i] - muY;
+		normX += sx * sx;
+		normY += sy * sy;
+		dot += sx * sy;
+	}
+	if (normX === 0 && normY === 0) return 0;
+	if (dot === 0) return 1;
+	return 1 - dot / Math.sqrt(normX * normY);
+}
+function hellinger(x, y) {
+	let result = 0;
+	let l1x = 0;
+	let l1y = 0;
+	for (let i = 0; i < x.length; i++) {
+		result += Math.sqrt(x[i] * y[i]);
+		l1x += x[i];
+		l1y += y[i];
+	}
+	if (l1x === 0 && l1y === 0) return 0;
+	if (l1x === 0 || l1y === 0) return 1;
+	return Math.sqrt(1 - result / Math.sqrt(l1x * l1y));
+}
+function approxLogGamma(x) {
+	if (x === 1) return 0;
+	return x * Math.log(x) - x + .5 * Math.log(2 * Math.PI / x) + 1 / (x * 12);
+}
+function logBeta(x, y) {
+	const a = Math.min(x, y);
+	const b = Math.max(x, y);
+	if (b < 5) {
+		let value = -Math.log(b);
+		for (let i = 1; i < Math.trunc(a); i++) value += Math.log(i) - Math.log(b + i);
+		return value;
+	}
+	return approxLogGamma(x) + approxLogGamma(y) - approxLogGamma(x + y);
+}
+function logSingleBeta(x) {
+	return Math.log(2) * (-2 * x + .5) + .5 * Math.log(2 * Math.PI / x) + .125 / x;
+}
+function llDirichlet(data1, data2) {
+	let n1 = 0;
+	let n2 = 0;
+	for (let i = 0; i < data1.length; i++) n1 += data1[i];
+	for (let i = 0; i < data2.length; i++) n2 += data2[i];
+	let logB = 0;
+	let selfDenom1 = 0;
+	let selfDenom2 = 0;
+	for (let i = 0; i < data1.length; i++) {
+		const d1 = data1[i];
+		const d2 = data2[i];
+		if (d1 * d2 > .9) {
+			logB += logBeta(d1, d2);
+			selfDenom1 += logSingleBeta(d1);
+			selfDenom2 += logSingleBeta(d2);
+		} else {
+			if (d1 > .9) selfDenom1 += logSingleBeta(d1);
+			if (d2 > .9) selfDenom2 += logSingleBeta(d2);
+		}
+	}
+	return Math.sqrt(1 / n2 * (logB - logBeta(n1, n2) - (selfDenom2 - logSingleBeta(n2))) + 1 / n1 * (logB - logBeta(n2, n1) - (selfDenom1 - logSingleBeta(n1))));
+}
+/**
+* Symmetrized KL divergence. NOTE: the Python source mutates its inputs (adds z,
+* normalizes in place); we copy to preserve the same numerics without side effects.
+*/
+function symmetricKl(x, y, z = 1e-11) {
+	const n = x.length;
+	let xSum = 0;
+	let ySum = 0;
+	const xs = new Float64Array(n);
+	const ys = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		xs[i] = x[i] + z;
+		xSum += xs[i];
+		ys[i] = y[i] + z;
+		ySum += ys[i];
+	}
+	for (let i = 0; i < n; i++) {
+		xs[i] = xs[i] / xSum;
+		ys[i] = ys[i] / ySum;
+	}
+	let kl1 = 0;
+	let kl2 = 0;
+	for (let i = 0; i < n; i++) {
+		kl1 += xs[i] * Math.log(xs[i] / ys[i]);
+		kl2 += ys[i] * Math.log(ys[i] / xs[i]);
+	}
+	return (kl1 + kl2) / 2;
+}
+function haversine(x, y) {
+	if (x.length !== 2) throw new UmapValidationError("haversine is only defined for 2 dimensional data");
+	const sinLat = Math.sin(.5 * (x[0] - y[0]));
+	const sinLong = Math.sin(.5 * (x[1] - y[1]));
+	const result = Math.sqrt(sinLat * sinLat + Math.cos(x[0]) * Math.cos(y[0]) * sinLong * sinLong);
+	return 2 * Math.asin(result);
+}
+function simple(fn, canonical) {
+	return {
+		canonical,
+		resolve: () => fn
+	};
+}
+const SPECS = {
+	euclidean: simple(euclidean, "euclidean"),
+	l2: simple(euclidean, "euclidean"),
+	sqeuclidean: simple(sqeuclidean, "sqeuclidean"),
+	manhattan: simple(manhattan, "manhattan"),
+	taxicab: simple(manhattan, "manhattan"),
+	l1: simple(manhattan, "manhattan"),
+	chebyshev: simple(chebyshev, "chebyshev"),
+	linfinity: simple(chebyshev, "chebyshev"),
+	linfty: simple(chebyshev, "chebyshev"),
+	linf: simple(chebyshev, "chebyshev"),
+	minkowski: {
+		canonical: "minkowski",
+		needs: ["p"],
+		resolve: (o) => {
+			const p = o.p ?? 2;
+			return (x, y) => minkowski(x, y, p);
+		}
+	},
+	seuclidean: {
+		canonical: "seuclidean",
+		needs: ["V"],
+		resolve: (o) => {
+			if (!o.V) throw new UmapValidationError("metric 'seuclidean' requires metricOptions.V");
+			const V = o.V;
+			return (x, y) => standardisedEuclidean(x, y, V);
+		}
+	},
+	standardised_euclidean: {
+		canonical: "seuclidean",
+		needs: ["V"],
+		resolve: (o) => {
+			if (!o.V) throw new UmapValidationError("metric 'standardised_euclidean' requires metricOptions.V");
+			const V = o.V;
+			return (x, y) => standardisedEuclidean(x, y, V);
+		}
+	},
+	wminkowski: {
+		canonical: "wminkowski",
+		needs: ["w", "p"],
+		resolve: (o) => {
+			if (!o.w) throw new UmapValidationError("metric 'wminkowski' requires metricOptions.w");
+			const w = o.w;
+			const p = o.p ?? 2;
+			return (x, y) => weightedMinkowski(x, y, w, p);
+		}
+	},
+	weighted_minkowski: {
+		canonical: "wminkowski",
+		needs: ["w", "p"],
+		resolve: (o) => {
+			if (!o.w) throw new UmapValidationError("metric 'weighted_minkowski' requires metricOptions.w");
+			const w = o.w;
+			const p = o.p ?? 2;
+			return (x, y) => weightedMinkowski(x, y, w, p);
+		}
+	},
+	mahalanobis: {
+		canonical: "mahalanobis",
+		needs: ["VInv"],
+		resolve: (o) => {
+			if (!o.VInv) throw new UmapValidationError("metric 'mahalanobis' requires metricOptions.VInv");
+			const VInv = o.VInv;
+			return (x, y) => mahalanobis(x, y, VInv);
+		}
+	},
+	canberra: simple(canberra, "canberra"),
+	braycurtis: simple(brayCurtis, "braycurtis"),
+	cosine: simple(cosine, "cosine"),
+	correlation: simple(correlation, "correlation"),
+	haversine: simple(haversine, "haversine"),
+	hamming: simple(hamming, "hamming"),
+	jaccard: simple(jaccard, "jaccard"),
+	dice: simple(dice, "dice"),
+	matching: simple(matching, "matching"),
+	kulsinski: simple(kulsinski, "kulsinski"),
+	rogerstanimoto: simple(rogersTanimoto, "rogerstanimoto"),
+	russellrao: simple(russellrao, "russellrao"),
+	sokalmichener: simple(sokalMichener, "sokalmichener"),
+	sokalsneath: simple(sokalSneath, "sokalsneath"),
+	yule: simple(yule, "yule"),
+	hellinger: simple(hellinger, "hellinger"),
+	ll_dirichlet: simple(llDirichlet, "ll_dirichlet"),
+	symmetric_kl: simple(symmetricKl, "symmetric_kl")
+};
+const NAMED_METRICS = Object.keys(SPECS);
+function resolveMetric(name, options = {}) {
+	const spec = SPECS[name];
+	if (!spec) throw new UmapValidationError(`unknown metric '${name}' — named metrics: ${NAMED_METRICS.join(", ")}`);
+	return spec.resolve(options);
+}
+
+//#endregion
+//#region src/knn/internal-metrics.ts
+const FLOAT32_MAX = 34028234663852886e22;
+function squaredEuclidean(x, y) {
+	let r = 0;
+	const n = x.length;
+	let i = 0;
+	const n4 = n - n % 4;
+	for (; i < n4; i += 4) {
+		const d0 = x[i] - y[i];
+		const d1 = x[i + 1] - y[i + 1];
+		const d2 = x[i + 2] - y[i + 2];
+		const d3 = x[i + 3] - y[i + 3];
+		r += d0 * d0 + d1 * d1 + d2 * d2 + d3 * d3;
+	}
+	for (; i < n; i++) {
+		const d = x[i] - y[i];
+		r += d * d;
+	}
+	return r;
+}
+/** alternative_cosine (distances.py:583-630). */
+function alternativeCosine(x, y) {
+	let dot = 0;
+	let nx = 0;
+	let ny = 0;
+	for (let i = 0; i < x.length; i++) {
+		dot += x[i] * y[i];
+		nx += x[i] * x[i];
+		ny += y[i] * y[i];
+	}
+	if (nx === 0 && ny === 0) return 0;
+	if (nx === 0 || ny === 0) return FLOAT32_MAX;
+	if (dot <= 0) return FLOAT32_MAX;
+	return Math.log2(Math.sqrt(nx * ny) / dot);
+}
+/** alternative_hellinger (distances.py:1387-1416). */
+function alternativeHellinger(x, y) {
+	let result = 0;
+	let l1x = 0;
+	let l1y = 0;
+	for (let i = 0; i < x.length; i++) {
+		result += Math.sqrt(x[i] * y[i]);
+		l1x += x[i];
+		l1y += y[i];
+	}
+	if (l1x === 0 && l1y === 0) return 0;
+	if (l1x === 0 || l1y === 0) return FLOAT32_MAX;
+	if (result <= 0) return FLOAT32_MAX;
+	return Math.log2(Math.sqrt(l1x * l1y) / result);
+}
+/** alternative_jaccard (distances.py:259-336 family). */
+function alternativeJaccard(x, y) {
+	let numNonZero = 0;
+	let numEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numNonZero += xt || yt ? 1 : 0;
+		numEqual += xt && yt ? 1 : 0;
+	}
+	if (numNonZero === 0) return 0;
+	if (numEqual === 0) return FLOAT32_MAX;
+	return -Math.log2(numEqual / numNonZero);
+}
+const identity = (d) => d;
+/** Metric names that switch NNDescent to angular trees (pynndescent_.py:1059-1077). */
+const ANGULAR_TREE_METRICS = new Set([
+	"cosine",
+	"dot",
+	"correlation",
+	"dice",
+	"jaccard",
+	"hellinger",
+	"hamming"
+]);
+/**
+* Resolve the internal metric + correction for NN-descent
+* (fast_distance_alternatives, distances.py:2170-2188).
+*/
+function resolveInternalMetric(name, options) {
+	const angularTrees = ANGULAR_TREE_METRICS.has(name);
+	switch (name) {
+		case "euclidean":
+		case "l2": return {
+			dist: squaredEuclidean,
+			correction: (d) => Math.sqrt(d),
+			angularTrees
+		};
+		case "cosine": return {
+			dist: alternativeCosine,
+			correction: (d) => 1 - 2 ** -d,
+			angularTrees
+		};
+		case "hellinger": return {
+			dist: alternativeHellinger,
+			correction: (d) => Math.sqrt(1 - 2 ** -d),
+			angularTrees
+		};
+		case "jaccard": return {
+			dist: alternativeJaccard,
+			correction: (d) => 1 - 2 ** -d,
+			angularTrees
+		};
+		default: return {
+			dist: resolveMetric(name, options),
+			correction: identity,
+			angularTrees
+		};
+	}
+}
+
+//#endregion
+//#region src/rng.ts
+/**
+* taus88 combined Tausworthe step, structurally identical to umap's `tau_rand_int`
+* but on u32 words (Python runs it on int64 with 32-bit truncations). Used for the
+* SGD negative-sampling stream; parity with Python is statistical, not bitwise (§5.5).
+* Returns a signed int32.
+*/
+function tauRandInt(state$1) {
+	const s0 = state$1[0] >>> 0;
+	const s1 = state$1[1] >>> 0;
+	const s2 = state$1[2] >>> 0;
+	state$1[0] = (s0 & 4294967294) << 12 ^ (s0 << 13 >>> 0 ^ s0) >>> 19 | 0;
+	state$1[1] = (s1 & 4294967288) << 4 ^ (s1 << 2 >>> 0 ^ s1) >>> 25 | 0;
+	state$1[2] = (s2 & 4294967280) << 17 ^ (s2 << 3 >>> 0 ^ s2) >>> 11 | 0;
+	return state$1[0] ^ state$1[1] ^ state$1[2] | 0;
+}
+/** Floor-mod (Python `%` semantics) of a signed int by a positive int. */
+function floorMod(a, n) {
+	const r = a % n;
+	return r < 0 ? r + n : r;
+}
+
+//#endregion
+//#region src/knn/nndescent.ts
+/** init_rp_tree: all pairs within each leaf. */
+function initRpTree(nLeaves, leafCols, leafArray, heap, dist, leafAcceptance = "max") {
+	const k = heap.size;
+	const distances = heap.distances;
+	const either = leafAcceptance === "either";
+	for (let leaf = 0; leaf < nLeaves; leaf++) {
+		const base = leaf * leafCols;
+		for (let a = 0; a < leafCols; a++) {
+			const p = leafArray[base + a];
+			if (p < 0) break;
+			for (let b = a + 1; b < leafCols; b++) {
+				const q = leafArray[base + b];
+				if (q < 0) break;
+				const d = dist(p, q);
+				if (either ? d < distances[p * k] || d < distances[q * k] : d < Math.max(distances[p * k], distances[q * k])) {
+					checkedFlaggedHeapPush(heap, p, d, q, 1);
+					checkedFlaggedHeapPush(heap, q, d, p, 1);
+				}
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/knn/rpforest.ts
+const RP_EPS = 1e-8;
+function defaultLeafSize(nNeighbors) {
+	return Math.max(60, Math.min(256, 5 * nNeighbors));
+}
+function partition(indices, side, nLeft, nRight) {
+	const left = new Int32Array(nLeft);
+	const right = new Int32Array(nRight);
+	let il = 0;
+	let ir = 0;
+	for (let i = 0; i < indices.length; i++) if (side[i] === 0) left[il++] = indices[i];
+	else right[ir++] = indices[i];
+	return {
+		left,
+		right
+	};
+}
+function euclideanSplit(data, dim, indices, rngState) {
+	const n = indices.length;
+	const leftIndex = floorMod(tauRandInt(rngState), n);
+	let rightIndex = floorMod(tauRandInt(rngState), n);
+	if (leftIndex === rightIndex) rightIndex += 1;
+	rightIndex = floorMod(rightIndex, n);
+	const l = indices[leftIndex];
+	const r = indices[rightIndex];
+	const hyperplane = new Float32Array(dim);
+	let offset = 0;
+	for (let d = 0; d < dim; d++) {
+		const hv = data[l * dim + d] - data[r * dim + d];
+		hyperplane[d] = hv;
+		offset -= hv * (data[l * dim + d] + data[r * dim + d]) / 2;
+	}
+	const side = new Uint8Array(n);
+	let nLeft = 0;
+	let nRight = 0;
+	for (let i = 0; i < n; i++) {
+		let margin = offset;
+		const p = indices[i];
+		for (let d = 0; d < dim; d++) margin += hyperplane[d] * data[p * dim + d];
+		if (Math.abs(margin) < RP_EPS) side[i] = Math.abs(tauRandInt(rngState)) % 2;
+		else if (margin > 0) side[i] = 0;
+		else side[i] = 1;
+		if (side[i] === 0) nLeft++;
+		else nRight++;
+	}
+	if (nLeft === 0 || nRight === 0) {
+		nLeft = 0;
+		nRight = 0;
+		for (let i = 0; i < n; i++) {
+			side[i] = floorMod(tauRandInt(rngState), 2);
+			if (side[i] === 0) nLeft++;
+			else nRight++;
+		}
+	}
+	const { left, right } = partition(indices, side, nLeft, nRight);
+	return {
+		left,
+		right,
+		hyperplane,
+		offset
+	};
+}
+function angularSplit(data, dim, indices, rngState) {
+	const n = indices.length;
+	const leftIndex = floorMod(tauRandInt(rngState), n);
+	let rightIndex = floorMod(tauRandInt(rngState), n);
+	if (leftIndex === rightIndex) rightIndex += 1;
+	rightIndex = floorMod(rightIndex, n);
+	const l = indices[leftIndex];
+	const r = indices[rightIndex];
+	let leftNorm = 0;
+	let rightNorm = 0;
+	for (let d = 0; d < dim; d++) {
+		leftNorm += data[l * dim + d] * data[l * dim + d];
+		rightNorm += data[r * dim + d] * data[r * dim + d];
+	}
+	leftNorm = Math.sqrt(leftNorm);
+	rightNorm = Math.sqrt(rightNorm);
+	if (Math.abs(leftNorm) < RP_EPS) leftNorm = 1;
+	if (Math.abs(rightNorm) < RP_EPS) rightNorm = 1;
+	const hyperplane = new Float32Array(dim);
+	let hnorm = 0;
+	for (let d = 0; d < dim; d++) {
+		const hv = data[l * dim + d] / leftNorm - data[r * dim + d] / rightNorm;
+		hyperplane[d] = hv;
+		hnorm += hv * hv;
+	}
+	hnorm = Math.sqrt(hnorm);
+	if (Math.abs(hnorm) < RP_EPS) hnorm = 1;
+	for (let d = 0; d < dim; d++) hyperplane[d] = hyperplane[d] / hnorm;
+	const side = new Uint8Array(n);
+	let nLeft = 0;
+	let nRight = 0;
+	for (let i = 0; i < n; i++) {
+		let margin = 0;
+		const p = indices[i];
+		for (let d = 0; d < dim; d++) margin += hyperplane[d] * data[p * dim + d];
+		if (Math.abs(margin) < RP_EPS) side[i] = floorMod(tauRandInt(rngState), 2);
+		else if (margin > 0) side[i] = 0;
+		else side[i] = 1;
+		if (side[i] === 0) nLeft++;
+		else nRight++;
+	}
+	if (nLeft === 0 || nRight === 0) {
+		nLeft = 0;
+		nRight = 0;
+		for (let i = 0; i < n; i++) {
+			side[i] = floorMod(tauRandInt(rngState), 2);
+			if (side[i] === 0) nLeft++;
+			else nRight++;
+		}
+	}
+	const { left, right } = partition(indices, side, nLeft, nRight);
+	return {
+		left,
+		right,
+		hyperplane,
+		offset: 0
+	};
+}
+function buildTree(data, dim, indices, leafSize, maxDepth, angular, rngState) {
+	if (indices.length > leafSize && maxDepth > 0) {
+		const { left, right, hyperplane, offset } = angular ? angularSplit(data, dim, indices, rngState) : euclideanSplit(data, dim, indices, rngState);
+		return {
+			left: buildTree(data, dim, left, leafSize, maxDepth - 1, angular, rngState),
+			right: buildTree(data, dim, right, leafSize, maxDepth - 1, angular, rngState),
+			hyperplane,
+			offset,
+			points: null
+		};
+	}
+	return {
+		left: null,
+		right: null,
+		hyperplane: null,
+		offset: 0,
+		points: indices
+	};
+}
+/** Flatten to preorder (convert_tree_format, rp_trees.py:3019-3049). */
+function flattenTree(root, nPoints, dim) {
+	let nNodes = 0;
+	let maxLeaf = 0;
+	const count = (node) => {
+		nNodes++;
+		if (node.points) {
+			if (node.points.length > maxLeaf) maxLeaf = node.points.length;
+		} else {
+			count(node.left);
+			count(node.right);
+		}
+	};
+	count(root);
+	const hyperplanes = new Float32Array(nNodes * dim);
+	const offsets = new Float32Array(nNodes);
+	const children = new Int32Array(nNodes * 2).fill(-1);
+	const indices = new Int32Array(nPoints).fill(-1);
+	let nodeNum = 0;
+	let leafStart = 0;
+	const walk = (node) => {
+		const my = nodeNum;
+		if (node.points) {
+			children[my * 2] = -leafStart;
+			children[my * 2 + 1] = -(leafStart + node.points.length);
+			indices.set(node.points, leafStart);
+			leafStart += node.points.length;
+			return;
+		}
+		hyperplanes.set(node.hyperplane, my * dim);
+		offsets[my] = node.offset;
+		nodeNum++;
+		children[my * 2] = nodeNum;
+		walk(node.left);
+		nodeNum++;
+		children[my * 2 + 1] = nodeNum;
+		walk(node.right);
+	};
+	walk(root);
+	return {
+		hyperplanes,
+		offsets,
+		children,
+		indices,
+		leafSize: maxLeaf,
+		nNodes,
+		dim
+	};
+}
+/** make_forest: per-tree tau states drawn from the master PRNG. */
+function makeForest(X, nNeighbors, nTrees, treeStates, { leafSize, angular = false, maxDepth = 200 } = {}) {
+	const ls = leafSize ?? defaultLeafSize(nNeighbors);
+	const all = new Int32Array(X.rows);
+	for (let i = 0; i < X.rows; i++) all[i] = i;
+	const forest = [];
+	for (let t = 0; t < nTrees; t++) {
+		const root = buildTree(X.data, X.cols, all.slice(), ls, maxDepth, angular, treeStates[t]);
+		forest.push(flattenTree(root, X.rows, X.cols));
+	}
+	return forest;
+}
+/** rptree_leaf_array: rows = leaves, padded with -1 to the forest-wide max leaf size. */
+function leafArrayFromForest(forest) {
+	if (forest.length === 0) return {
+		data: new Int32Array([-1]),
+		rows: 1,
+		cols: 1
+	};
+	let maxLeafSize = 0;
+	for (const t of forest) maxLeafSize = Math.max(maxLeafSize, t.leafSize);
+	const rows = [];
+	for (const t of forest) for (let node = 0; node < t.nNodes; node++) {
+		const c0 = t.children[node * 2];
+		if (c0 <= 0) {
+			const start = -c0;
+			const end = -t.children[node * 2 + 1];
+			const row = new Int32Array(maxLeafSize).fill(-1);
+			row.set(t.indices.subarray(start, end));
+			rows.push(row);
+		}
+	}
+	const out = new Int32Array(rows.length * maxLeafSize);
+	rows.forEach((r, i) => {
+		out.set(r, i * maxLeafSize);
+	});
+	return {
+		data: out,
+		rows: rows.length,
+		cols: maxLeafSize
+	};
+}
+
+//#endregion
+//#region src/layout/sgd.ts
+function clip(val) {
+	if (val > 4) return 4;
+	if (val < -4) return -4;
+	return val;
+}
+/** Per-vertex tau streams: base rng_state + bit-pattern of the vertex's first coord. */
+function perVertexRngStates(n, rngState, embedding, dim) {
+	const states = new Int32Array(n * 3);
+	const buf = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	for (let j = 0; j < n; j++) {
+		buf.setFloat64(0, embedding[j * dim], true);
+		const lo = buf.getInt32(0, true);
+		const hi = buf.getInt32(4, true);
+		states[j * 3] = rngState[0] + lo | 0;
+		states[j * 3 + 1] = rngState[1] + hi | 0;
+		states[j * 3 + 2] = rngState[2] + (lo ^ hi) | 0;
+	}
+	return states;
+}
+
+//#endregion
+//#region src/backends/cpu/worker.ts
+const state = {};
+const handlers = {
+	init(args) {
+		state.data = args.data;
+		state.rows = args.rows;
+		state.cols = args.cols;
+		state.internal = resolveInternalMetric(args.metricName, args.metricOptions);
+		return { result: true };
+	},
+	buildTrees(args) {
+		const leaves = leafArrayFromForest(makeForest({
+			data: state.data,
+			rows: state.rows,
+			cols: state.cols
+		}, args.nNeighbors, args.treeStates.length, args.treeStates.map((s) => Int32Array.from(s)), {
+			leafSize: defaultLeafSize(args.nNeighbors),
+			angular: args.angular
+		}));
+		return {
+			result: {
+				data: leaves.data,
+				rows: leaves.rows,
+				cols: leaves.cols
+			},
+			transfers: [leaves.data.buffer]
+		};
+	},
+	leafUpdates(args) {
+		const dist = state.internal.dist;
+		const dim = state.cols;
+		const data = state.data;
+		const out = [];
+		for (let leaf = args.rowStart; leaf < args.rowEnd; leaf++) {
+			const base = leaf * args.cols;
+			for (let a = 0; a < args.cols; a++) {
+				const p = args.leafArray[base + a];
+				if (p < 0) break;
+				for (let b = a + 1; b < args.cols; b++) {
+					const q = args.leafArray[base + b];
+					if (q < 0) break;
+					const d = dist(data.subarray(p * dim, (p + 1) * dim), data.subarray(q * dim, (q + 1) * dim));
+					if (d < Math.max(args.thresholds[p], args.thresholds[q])) out.push(p, q, d);
+				}
+			}
+		}
+		const triples = Float64Array.from(out);
+		return {
+			result: triples,
+			transfers: [triples.buffer]
+		};
+	},
+	joinUpdates(args) {
+		const dist = state.internal.dist;
+		const dim = state.cols;
+		const data = state.data;
+		const mc = args.maxCandidates;
+		const out = [];
+		for (let i = args.vStart; i < args.vEnd; i++) {
+			const base = i * mc;
+			for (let j = 0; j < mc; j++) {
+				const p = args.newIdx[base + j];
+				if (p < 0) continue;
+				const pRow = data.subarray(p * dim, (p + 1) * dim);
+				for (let t = j; t < mc; t++) {
+					const q = args.newIdx[base + t];
+					if (q < 0) continue;
+					const d = dist(pRow, data.subarray(q * dim, (q + 1) * dim));
+					if (d <= Math.max(args.thresholds[p], args.thresholds[q])) out.push(p, q, d);
+				}
+				for (let t = 0; t < mc; t++) {
+					const q = args.oldIdx[base + t];
+					if (q < 0) continue;
+					const d = dist(pRow, data.subarray(q * dim, (q + 1) * dim));
+					if (d <= Math.max(args.thresholds[p], args.thresholds[q])) out.push(p, q, d);
+				}
+			}
+		}
+		const triples = Float64Array.from(out);
+		return {
+			result: triples,
+			transfers: [triples.buffer]
+		};
+	},
+	leafInitHeap(args) {
+		const heap = makeHeap(state.rows, args.nNeighbors);
+		const dist = (i, j) => state.internal.dist(state.data.subarray(i * state.cols, (i + 1) * state.cols), state.data.subarray(j * state.cols, (j + 1) * state.cols));
+		initRpTree(args.rows, args.cols, args.leafArray, heap, dist);
+		return {
+			result: {
+				indices: heap.indices,
+				distances: heap.distances,
+				flags: heap.flags
+			},
+			transfers: [
+				heap.indices.buffer,
+				heap.distances.buffer,
+				heap.flags.buffer
+			]
+		};
+	},
+	layoutInit(args) {
+		state.embedding = args.embedding;
+		state.tailEmbedding = args.tailEmbedding ?? args.embedding;
+		state.head = args.head;
+		state.tail = args.tail;
+		state.epochsPerSample = args.epochsPerSample;
+		const nEdges = args.epochsPerSample.length;
+		const eons = new Float64Array(nEdges);
+		const epns = new Float64Array(nEdges);
+		for (let i = 0; i < nEdges; i++) {
+			eons[i] = args.epochsPerSample[i];
+			epns[i] = args.epochsPerSample[i] / args.params.negativeSampleRate;
+		}
+		state.epochOfNextSample = eons;
+		state.epochsPerNegativeSample = epns;
+		state.epochOfNextNegativeSample = epns.slice();
+		state.layoutParams = args.params;
+		state.vertexRng = perVertexRngStates(args.embedding.length / args.params.dim, args.rngState, args.embedding, args.params.dim);
+		return { result: true };
+	},
+	layoutEpoch(args) {
+		const p = state.layoutParams;
+		const head = state.head;
+		const tail = state.tail;
+		const eps = state.epochsPerSample;
+		const eons = state.epochOfNextSample;
+		const epns = state.epochsPerNegativeSample;
+		const eonns = state.epochOfNextNegativeSample;
+		const vertexRng = state.vertexRng;
+		const dim = p.dim;
+		const { a, b, gamma, negativeSampleRate } = p;
+		const alpha = args.alpha;
+		const n = args.epoch;
+		let emb = state.embedding;
+		let deltas = null;
+		let tailEmb = state.tailEmbedding;
+		if (!p.sharedEmbedding) {
+			emb = args.embedding;
+			tailEmb = p.moveOther ? emb : state.tailEmbedding;
+			deltas = new Float32Array(emb.length);
+		}
+		const rngRow = new Int32Array(3);
+		const write = (idx, v) => {
+			if (deltas) deltas[idx] = deltas[idx] + v;
+			else emb[idx] = emb[idx] + v;
+		};
+		for (let i = p.edgeStart; i < p.edgeEnd; i++) {
+			if (eons[i] > n) continue;
+			const j = head[i];
+			let k = tail[i];
+			const jBase = j * dim;
+			let kBase = k * dim;
+			let d2 = 0;
+			for (let d = 0; d < dim; d++) {
+				const diff = emb[jBase + d] - tailEmb[kBase + d];
+				d2 += diff * diff;
+			}
+			let gradCoeff = 0;
+			if (d2 > 0) gradCoeff = -2 * a * b * d2 ** (b - 1) / (a * d2 ** b + 1);
+			for (let d = 0; d < dim; d++) {
+				const diff = emb[jBase + d] - tailEmb[kBase + d];
+				const gradD = clip(gradCoeff * diff);
+				write(jBase + d, gradD * alpha);
+				if (p.moveOther) write(kBase + d, -gradD * alpha);
+			}
+			eons[i] = eons[i] + eps[i];
+			const nNeg = Math.trunc((n - eonns[i]) / epns[i]);
+			rngRow[0] = vertexRng[j * 3];
+			rngRow[1] = vertexRng[j * 3 + 1];
+			rngRow[2] = vertexRng[j * 3 + 2];
+			for (let s = 0; s < nNeg; s++) {
+				const r = tauRandInt(rngRow);
+				k = r % p.nVertices + (r % p.nVertices < 0 ? p.nVertices : 0);
+				kBase = k * dim;
+				let dn = 0;
+				for (let d = 0; d < dim; d++) {
+					const diff = emb[jBase + d] - tailEmb[kBase + d];
+					dn += diff * diff;
+				}
+				let repCoeff = 0;
+				if (dn > 0) repCoeff = 2 * gamma * b / ((.001 + dn) * (a * dn ** b + 1));
+				else if (j === k) continue;
+				for (let d = 0; d < dim; d++) if (repCoeff > 0) {
+					const diff = emb[jBase + d] - tailEmb[kBase + d];
+					write(jBase + d, clip(repCoeff * diff) * alpha);
+				}
+			}
+			vertexRng[j * 3] = rngRow[0];
+			vertexRng[j * 3 + 1] = rngRow[1];
+			vertexRng[j * 3 + 2] = rngRow[2];
+			eonns[i] = eonns[i] + nNeg * epns[i];
+		}
+		if (deltas) return {
+			result: deltas,
+			transfers: [deltas.buffer]
+		};
+		return { result: null };
+	}
+};
+function handle(msg, post) {
+	const h = handlers[msg.method];
+	if (!h) {
+		post({
+			id: msg.id,
+			error: `unknown method ${msg.method}`
+		});
+		return;
+	}
+	try {
+		const { result, transfers } = h(msg.args);
+		post({
+			id: msg.id,
+			result
+		}, transfers);
+	} catch (e) {
+		post({
+			id: msg.id,
+			error: e instanceof Error ? e.stack ?? e.message : String(e)
+		});
+	}
+}
+if (typeof process !== "undefined" && !!process.versions?.node) (async () => {
+	const { parentPort } = await import("node:worker_threads");
+	parentPort.on("message", (msg) => handle(msg, (m, t) => parentPort.postMessage(m, t ?? [])));
+})();
+else {
+	const scope = globalThis;
+	scope.onmessage = (e) => handle(e.data, (m, t) => scope.postMessage(m, { transfer: t ?? [] }));
+}
+
+//#endregion
+export {  };
+//# sourceMappingURL=worker.js.map