@mailwoman/match 8.1.0 → 8.2.0

package/blocking.ts

@@ -19,10 +19,14 @@
  *   default, and any block too large to scan is _reported_, never silently dropped.
  */
 
-/** Maps a record to zero or more block keys. Two records sharing any key become a candidate pair. */
+/**
+ * Maps a record to zero or more block keys. Two records sharing any key become a candidate pair.
+ */
 export type BlockingKey<R> = (record: R) => string[]
 
-/** A geographic coordinate (WGS84 decimal degrees). */
+/**
+ * A geographic coordinate (WGS84 decimal degrees).
+ */
 export interface LatLon {
 	latitude: number
 	longitude: number
@@ -75,7 +79,7 @@ export function exactKey<R>(
 	extract: (record: R) => string | null | undefined,
 	opts: { prefix?: number; normalize?: (value: string) => string } = {}
 ): BlockingKey<R> {
-	const normalize = opts.normalize ?? ((v: string) => v.trim().toLowerCase().replace(/\s+/g, " "))
+	const normalize = opts.normalize ?? ((v: string) => v.trim().toLowerCase().replaceAll(/\s+/g, " "))
 
 	return (record) => {
 		const value = extract(record)
@@ -101,7 +105,7 @@ export function conjunction<R>(...keys: BlockingKey<R>[]): BlockingKey<R> {
 		for (const key of keys) {
 			const parts = key(record)
 
-			if (parts.length === 0) return []
+			if (!parts.length) return []
 			combos = combos.flatMap((prefix) => parts.map((part) => (prefix ? `${prefix}&${part}` : part)))
 		}
 
@@ -109,11 +113,17 @@ export function conjunction<R>(...keys: BlockingKey<R>[]): BlockingKey<R> {
 	}
 }
 
-/** The outcome of a blocking pass. */
+/**
+ * The outcome of a blocking pass.
+ */
 export interface BlockResult<R> {
-	/** Deduplicated candidate pairs (no self-pairs; a pair caught by multiple keys appears once). */
+	/**
+	 * Deduplicated candidate pairs (no self-pairs; a pair caught by multiple keys appears once).
+	 */
 	pairs: Array<[R, R]>
-	/** Blocks that exceeded `maxBlockSize` and were skipped — surfaced so coverage limits are visible. */
+	/**
+	 * Blocks that exceeded `maxBlockSize` and were skipped — surfaced so coverage limits are visible.
+	 */
 	droppedBlocks: Array<{ key: string; size: number }>
 }
 
@@ -160,6 +170,7 @@ export function block<R>(
 
 		if (bucket.length > maxBlockSize) {
 			droppedBlocks.push({ key, size: bucket.length })
+
 			continue
 		}
 

package/clustering.ts

@@ -20,14 +20,18 @@
  *   across the whole dataset.
  */
 
-/** A scored candidate pair: two records and the match weight (bits) the scorer assigned them. */
+/**
+ * A scored candidate pair: two records and the match weight (bits) the scorer assigned them.
+ */
 export interface ScoredLink<R> {
 	a: R
 	b: R
 	weight: number
 }
 
-/** Options for {@link cluster}. */
+/**
+ * Options for {@link cluster}.
+ */
 export interface ClusterOptions {
 	/**
 	 * Link two records only when their match weight is at or above this (bits) — the precision/recall knob.
@@ -58,6 +62,7 @@ export interface ClusterOptions {
  */
 function averageLinkageRefine<R>(members: R[], edges: Array<[number, number, number]>, threshold: number): R[][] {
 	const clusters = members.map((_, i) => [i])
+
 	const crossAverage = (a: number[], b: number[]): number | null => {
 		const inA = new Set(a)
 		const inB = new Set(b)
@@ -67,6 +72,7 @@ function averageLinkageRefine<R>(members: R[], edges: Array<[number, number, num
 		for (const [i, j, w] of edges) {
 			if ((inA.has(i) && inB.has(j)) || (inA.has(j) && inB.has(i))) {
 				sum += w
+
 				count++
 			}
 		}
@@ -139,6 +145,7 @@ export function cluster<R>(records: readonly R[], links: Iterable<ScoredLink<R>>
 			parent[ry] = rx
 		} else {
 			parent[ry] = rx
+
 			rank[rx]!++
 		}
 	}
@@ -161,6 +168,7 @@ export function cluster<R>(records: readonly R[], links: Iterable<ScoredLink<R>>
 	}
 
 	const groups = new Map<number, R[]>()
+
 	records.forEach((record, i) => {
 		const root = find(i)
 		const group = groups.get(root)
@@ -183,6 +191,7 @@ export function cluster<R>(records: readonly R[], links: Iterable<ScoredLink<R>>
 	for (const members of groups.values()) {
 		members.forEach((m, i) => localOf.set(m, i))
 	}
+
 	const groupEdges = new Map<number, Array<[number, number, number]>>()
 
 	for (const link of allLinks) {
@@ -199,6 +208,7 @@ export function cluster<R>(records: readonly R[], links: Iterable<ScoredLink<R>>
 	for (const [root, members] of groups) {
 		if (members.length <= 1 || members.length > maxComponent) {
 			result.push(members)
+
 			continue
 		}
 

package/comparators.ts

@@ -44,7 +44,9 @@ export function jaro(a: string, b: string): number {
 			if (bMatched[j] || a[i] !== b[j]) continue
 			aMatched[i] = true
 			bMatched[j] = true
+
 			matches++
+
 			break
 		}
 	}
@@ -65,8 +67,10 @@ export function jaro(a: string, b: string): number {
 		if (a[i] !== b[k]) {
 			transpositions++
 		}
+
 		k++
 	}
+
 	transpositions /= 2
 
 	return (matches / la + matches / lb + (matches - transpositions) / matches) / 3
@@ -100,7 +104,9 @@ export function jaroWinkler(
 	return base + prefix * weight * (1 - base)
 }
 
-/** Normalized Levenshtein similarity in [0, 1]: `1 - editDistance / max(len)`. */
+/**
+ * Normalized Levenshtein similarity in [0, 1]: `1 - editDistance / max(len)`.
+ */
 export function levenshteinSimilarity(a: string, b: string): number {
 	if (a === b) return 1
 	const longest = Math.max(a.length, b.length)
@@ -122,8 +128,8 @@ export function levenshteinSimilarity(a: string, b: string): number {
  * Case- and whitespace-insensitive. Empty input scores 0.
  */
 export function nameSimilarity(a: string, b: string): number {
-	const x = a.trim().toLowerCase().replace(/\s+/g, " ")
-	const y = b.trim().toLowerCase().replace(/\s+/g, " ")
+	const x = a.trim().toLowerCase().replaceAll(/\s+/g, " ")
+	const y = b.trim().toLowerCase().replaceAll(/\s+/g, " ")
 
 	if (!x || !y) return 0
 

package/em.ts

@@ -29,26 +29,42 @@ import type { Comparison, FellegiSunterModel } from "./fellegi-sunter.ts"
  */
 const EPSILON = 1e-9
 
-/** Reduce a record pair to its agreement pattern — the per-comparison level index (`-1` = missing). */
+/**
+ * Reduce a record pair to its agreement pattern — the per-comparison level index (`-1` = missing).
+ */
 export function agreementPattern<R>(comparisons: Comparison<R>[], a: R, b: R): number[] {
 	return comparisons.map((comparison) => comparison.assess(a, b))
 }
 
-/** Options for {@link estimateParameters}. */
+/**
+ * Options for {@link estimateParameters}.
+ */
 export interface EmOptions {
-	/** Hard iteration cap. Default 100. */
+	/**
+	 * Hard iteration cap. Default 100.
+	 */
 	maxIterations?: number
-	/** Convergence tolerance on the largest parameter change between iterations. Default 1e-6. */
+	/**
+	 * Convergence tolerance on the largest parameter change between iterations. Default 1e-6.
+	 */
 	tolerance?: number
-	/** Starting prior match rate. Defaults to the model's `lambda`. */
+	/**
+	 * Starting prior match rate. Defaults to the model's `lambda`.
+	 */
 	initialLambda?: number
 }
 
-/** The fitted model plus convergence diagnostics. */
+/**
+ * The fitted model plus convergence diagnostics.
+ */
 export interface EmResult<R> {
-	/** The input model with every level's `m`/`u` and the prior `lambda` re-estimated. */
+	/**
+	 * The input model with every level's `m`/`u` and the prior `lambda` re-estimated.
+	 */
 	model: FellegiSunterModel<R>
-	/** The estimated prior match rate. */
+	/**
+	 * The estimated prior match rate.
+	 */
 	lambda: number
 	iterations: number
 	converged: boolean
@@ -77,7 +93,7 @@ export function estimateParameters<R>(
 	let iterations = 0
 	let converged = false
 
-	if (patterns.length === 0) {
+	if (!patterns.length) {
 		return { model, lambda, iterations, converged }
 	}
 
@@ -100,6 +116,7 @@ export function estimateParameters<R>(
 				matchLikelihood *= m[i]![level]!
 				nonMatchLikelihood *= u[i]![level]!
 			}
+
 			const total = matchLikelihood + nonMatchLikelihood
 			const g = total > 0 ? matchLikelihood / total : 0
 			responsibilitySum += g
@@ -126,8 +143,10 @@ export function estimateParameters<R>(
 			for (let l = 0; l < levels; l++) {
 				const newM =
 					mDenominator[i]! > 0 ? (mNumerator[i]![l]! + EPSILON) / (mDenominator[i]! + EPSILON * levels) : m[i]![l]!
+
 				const newU =
 					uDenominator[i]! > 0 ? (uNumerator[i]![l]! + EPSILON) / (uDenominator[i]! + EPSILON * levels) : u[i]![l]!
+
 				maxDelta = Math.max(maxDelta, Math.abs(newM - m[i]![l]!), Math.abs(newU - u[i]![l]!))
 				m[i]![l] = newM
 				u[i]![l] = newU
@@ -136,7 +155,9 @@ export function estimateParameters<R>(
 
 		if (maxDelta < tolerance) {
 			converged = true
+
 			iterations++
+
 			break
 		}
 	}

package/fellegi-sunter.ts

@@ -27,27 +27,47 @@
 
 import { nameSimilarity } from "./comparators.ts"
 
-/** One agreement level of a comparison, with its match / non-match probabilities. */
+/**
+ * One agreement level of a comparison, with its match / non-match probabilities.
+ */
 export interface ComparisonLevel {
-	/** Human-readable label for debugging (`exact`, `high`, `different`). */
+	/**
+	 * Human-readable label for debugging (`exact`, `high`, `different`).
+	 */
 	label: string
-	/** P(a pair lands in this level | it is a true match). A measure of data quality. */
+	/**
+	 * P(a pair lands in this level | it is a true match). A measure of data quality.
+	 */
 	m: number
-	/** P(a pair lands in this level | it is NOT a match). A measure of coincidence / cardinality. */
+	/**
+	 * P(a pair lands in this level | it is NOT a match). A measure of coincidence / cardinality.
+	 */
 	u: number
-	/** For similarity-driven comparisons: the minimum similarity (inclusive) to qualify. */
+	/**
+	 * For similarity-driven comparisons: the minimum similarity (inclusive) to qualify.
+	 */
 	minSimilarity?: number
-	/** For distance-driven comparisons: the maximum distance in km (inclusive) to qualify. */
+	/**
+	 * For distance-driven comparisons: the maximum distance in km (inclusive) to qualify.
+	 */
 	maxKm?: number
 }
 
-/** A per-field comparison: pull a value from each record and assign an agreement level. */
+/**
+ * A per-field comparison: pull a value from each record and assign an agreement level.
+ */
 export interface Comparison<R> {
-	/** Field name, for attribution. */
+	/**
+	 * Field name, for attribution.
+	 */
 	name: string
-	/** Levels ordered highest agreement → lowest (`exact` first, `different` last). */
+	/**
+	 * Levels ordered highest agreement → lowest (`exact` first, `different` last).
+	 */
 	levels: ComparisonLevel[]
-	/** Index into {@link levels}, or `-1` when either value is missing (no evidence → weight 0). */
+	/**
+	 * Index into {@link levels}, or `-1` when either value is missing (no evidence → weight 0).
+	 */
 	assess(a: R, b: R): number
 	/**
 	 * Optional term-frequency adjustment: on the levels it names, replace the level's average `u` with the agreeing
@@ -64,46 +84,74 @@ export interface Comparison<R> {
  * {@link TermFrequencyAdjustment.minimumFrequency} so an ultra-rare value can't produce an unbounded boost.
  */
 export interface TermFrequencyAdjustment<R> {
-	/** Relative frequency of a value in the data, in (0, 1]. Typically computed on-the-fly. */
+	/**
+	 * Relative frequency of a value in the data, in (0, 1]. Typically computed on-the-fly.
+	 */
 	frequency(value: string): number
-	/** The level indices the adjustment applies to (typically just the exact level). */
+	/**
+	 * The level indices the adjustment applies to (typically just the exact level).
+	 */
 	levels: ReadonlySet<number>
-	/** The agreeing value to look up for a pair (a normalized field value), or null to skip. */
+	/**
+	 * The agreeing value to look up for a pair (a normalized field value), or null to skip.
+	 */
 	value(a: R, b: R): string | null | undefined
-	/** Scale the adjustment in [0, 1]. Default 1. */
+	/**
+	 * Scale the adjustment in [0, 1]. Default 1.
+	 */
 	weight?: number
-	/** Floor for the looked-up frequency, bounding the boost on ultra-rare values. Default 1e-4. */
+	/**
+	 * Floor for the looked-up frequency, bounding the boost on ultra-rare values. Default 1e-4.
+	 */
 	minimumFrequency?: number
 }
 
-/** A Fellegi-Sunter model: the field comparisons plus the prior match rate `λ`. */
+/**
+ * A Fellegi-Sunter model: the field comparisons plus the prior match rate `λ`.
+ */
 export interface FellegiSunterModel<R> {
 	comparisons: Comparison<R>[]
-	/** Prior probability that two records drawn at random are a match. */
+	/**
+	 * Prior probability that two records drawn at random are a match.
+	 */
 	lambda: number
 }
 
-/** The scored outcome for one record pair. */
+/**
+ * The scored outcome for one record pair.
+ */
 export interface PairScore {
-	/** Total match weight in bits (`log2` odds). */
+	/**
+	 * Total match weight in bits (`log2` odds).
+	 */
 	weight: number
-	/** Match probability in [0, 1]. */
+	/**
+	 * Match probability in [0, 1].
+	 */
 	probability: number
-	/** Per-field breakdown — what drove the score. */
+	/**
+	 * Per-field breakdown — what drove the score.
+	 */
 	contributions: Array<{ name: string; level: string | null; weight: number }>
 }
 
-/** The terminal decision for a pair under upper / lower match-weight thresholds. */
+/**
+ * The terminal decision for a pair under upper / lower match-weight thresholds.
+ */
 export type MatchDecision = "match" | "review" | "non-match"
 
-/** The Bayes-factor weight of a single level, in bits: `log2(m / u)`. */
+/**
+ * The Bayes-factor weight of a single level, in bits: `log2(m / u)`.
+ */
 export function levelWeight(level: ComparisonLevel): number {
 	if (level.u <= 0) return level.m > 0 ? Infinity : 0
 
 	return Math.log2(level.m / level.u)
 }
 
-/** The prior match weight in bits: `log2(λ / (1 - λ))`. */
+/**
+ * The prior match weight in bits: `log2(λ / (1 - λ))`.
+ */
 export function priorWeight(lambda: number): number {
 	if (lambda <= 0) return -Infinity
 
@@ -112,7 +160,9 @@ export function priorWeight(lambda: number): number {
 	return Math.log2(lambda / (1 - lambda))
 }
 
-/** Convert a total match weight (bits) to a probability, numerically stable for extreme weights. */
+/**
+ * Convert a total match weight (bits) to a probability, numerically stable for extreme weights.
+ */
 export function probabilityFromWeight(weight: number): number {
 	return 1 / (1 + 2 ** -weight)
 }
@@ -125,7 +175,9 @@ export function probabilityFromWeight(weight: number): number {
 export function similarityComparison<R>(config: {
 	name: string
 	extract: (record: R) => string | null | undefined
-	/** Defaults to {@link nameSimilarity}. */
+	/**
+	 * Defaults to {@link nameSimilarity}.
+	 */
 	similarity?: (a: string, b: string) => number
 	levels: ComparisonLevel[]
 }): Comparison<R> {
@@ -151,7 +203,9 @@ export function similarityComparison<R>(config: {
 	}
 }
 
-/** Score a record pair: total match weight, probability, and the per-field contributions. */
+/**
+ * Score a record pair: total match weight, probability, and the per-field contributions.
+ */
 export function scorePair<R>(model: FellegiSunterModel<R>, a: R, b: R): PairScore {
 	let weight = priorWeight(model.lambda)
 	const contributions: PairScore["contributions"] = []
@@ -161,8 +215,10 @@ export function scorePair<R>(model: FellegiSunterModel<R>, a: R, b: R): PairScor
 
 		if (index < 0) {
 			contributions.push({ name: comparison.name, level: null, weight: 0 })
+
 			continue
 		}
+
 		const level = comparison.levels[index]!
 		let w = levelWeight(level)
 

package/gbt.ts

@@ -18,7 +18,19 @@
  *       trains offline once and ships as a data file.
  */
 
-/** A trained tree: an internal split (feature `f` ≤ `thr` → `lo`, else `hi`) or a `leaf` value. */
+/**
+ * Distinct values at or below which every split point is tried exactly rather than by quantile.
+ */
+const MAX_EXACT_SPLIT_VALUES = 5
+
+/**
+ * Quantile split points evaluated for a continuous feature.
+ */
+const QUANTILE_SPLIT_COUNT = 6
+
+/**
+ * A trained tree: an internal split (feature `f` ≤ `thr` → `lo`, else `hi`) or a `leaf` value.
+ */
 export type TreeNode = { leaf: number } | { f: number; thr: number; lo: TreeNode; hi: TreeNode }
 
 const sigmoid = (z: number): number => 1 / (1 + Math.exp(-Math.max(-30, Math.min(30, z))))
@@ -32,24 +44,26 @@ export function buildThresholds(X: number[][]): number[][] {
 
 	for (let f = 0; f < dim; f++) {
 		const vals = X.map((r) => r[f]!)
-		const uniq = [...new Set(vals)].sort((p, q) => p - q)
+		const uniq = [...new Set(vals)].toSorted((p, q) => p - q)
 
 		if (uniq.length <= 1) {
 			out.push([])
-		} else if (uniq.length <= 5) {
+		} else if (uniq.length <= MAX_EXACT_SPLIT_VALUES) {
 			const t: number[] = []
 
 			for (let k = 0; k < uniq.length - 1; k++) {
 				t.push((uniq[k]! + uniq[k + 1]!) / 2)
 			}
+
 			out.push(t)
 		} else {
-			const sorted = [...vals].sort((p, q) => p - q)
+			const sorted = [...vals].toSorted((p, q) => p - q)
 			const t: number[] = []
 
-			for (let q = 1; q <= 6; q++) {
+			for (let q = 1; q <= QUANTILE_SPLIT_COUNT; q++) {
 				t.push(sorted[Math.floor((q / 7) * (sorted.length - 1))]!)
 			}
+
 			out.push([...new Set(t)])
 		}
 	}
@@ -57,7 +71,9 @@ export function buildThresholds(X: number[][]): number[][] {
 	return out
 }
 
-/** Weighted SSE of target `g` over `rows` around their weighted mean. */
+/**
+ * Weighted SSE of target `g` over `rows` around their weighted mean.
+ */
 function nodeSSE(rows: number[], g: number[], w: number[]): number {
 	let wsum = 0
 	let wg = 0
@@ -66,6 +82,7 @@ function nodeSSE(rows: number[], g: number[], w: number[]): number {
 		wsum += w[i]!
 		wg += w[i]! * g[i]!
 	}
+
 	const mean = wsum > 0 ? wg / wsum : 0
 	let sse = 0
 
@@ -77,7 +94,9 @@ function nodeSSE(rows: number[], g: number[], w: number[]): number {
 	return sse
 }
 
-/** Greedy depth-limited weighted regression tree on target `g` (the boosting residual). */
+/**
+ * Greedy depth-limited weighted regression tree on target `g` (the boosting residual).
+ */
 function fitRegTree(
 	rows: number[],
 	X: number[][],
@@ -94,6 +113,7 @@ function fitRegTree(
 		wsum += w[i]!
 		wg += w[i]! * g[i]!
 	}
+
 	const leaf = wsum > 0 ? wg / wsum : 0
 
 	if (depth === 0 || rows.length < 2 * minLeaf) return { leaf }
@@ -146,14 +166,18 @@ function predictTree(t: TreeNode, x: number[]): number {
 	return n.leaf
 }
 
-/** A trained gradient-boosted-tree model: an additive ensemble over a base log-odds. Plain JSON. */
+/**
+ * A trained gradient-boosted-tree model: an additive ensemble over a base log-odds. Plain JSON.
+ */
 export interface GBT {
 	trees: TreeNode[]
 	lr: number
 	base: number
 }
 
-/** Hyperparameters for {@link trainGBT}. */
+/**
+ * Hyperparameters for {@link trainGBT}.
+ */
 export interface GBTOpts {
 	rounds: number
 	depth: number
@@ -161,7 +185,9 @@ export interface GBTOpts {
 	minLeaf: number
 }
 
-/** Gradient-boosted regression trees on logistic loss, with per-sample class weights `w`. */
+/**
+ * Gradient-boosted regression trees on logistic loss, with per-sample class weights `w`.
+ */
 export function trainGBT(X: number[][], y: number[], w: number[], opts: GBTOpts): GBT {
 	const N = X.length
 	const thresholds = buildThresholds(X)
@@ -176,6 +202,7 @@ export function trainGBT(X: number[][], y: number[], w: number[], opts: GBTOpts)
 			wpos += w[i]!
 		}
 	}
+
 	const base = Math.log((wpos + 1) / (wtot - wpos + 1)) // weighted base log-odds
 	const F = new Array<number>(N).fill(base)
 	const trees: TreeNode[] = []
@@ -185,19 +212,24 @@ export function trainGBT(X: number[][], y: number[], w: number[], opts: GBTOpts)
 
 		for (let i = 0; i < N; i++) {
 			g[i] = y[i]! - sigmoid(F[i]!)
-		} // negative gradient of logistic loss
+		}
+
+		// negative gradient of logistic loss
 		const tree = fitRegTree(rowsAll, X, g, w, thresholds, opts.depth, opts.minLeaf)
 
 		for (let i = 0; i < N; i++) {
 			F[i]! += opts.lr * predictTree(tree, X[i]!)
 		}
+
 		trees.push(tree)
 	}
 
 	return { trees, lr: opts.lr, base }
 }
 
-/** GBT score (logit) for one feature vector. Threshold-comparable like the FS weight. */
+/**
+ * GBT score (logit) for one feature vector. Threshold-comparable like the FS weight.
+ */
 export function gbtScore(m: GBT, x: number[]): number {
 	let f = m.base
 

package/out/blocking.d.ts

@@ -18,9 +18,13 @@
  *   silent failure in record linkage. So the spatial grid is generous and neighbour-expanded by
  *   default, and any block too large to scan is _reported_, never silently dropped.
  */
-/** Maps a record to zero or more block keys. Two records sharing any key become a candidate pair. */
+/**
+ * Maps a record to zero or more block keys. Two records sharing any key become a candidate pair.
+ */
 export type BlockingKey<R> = (record: R) => string[];
-/** A geographic coordinate (WGS84 decimal degrees). */
+/**
+ * A geographic coordinate (WGS84 decimal degrees).
+ */
 export interface LatLon {
     latitude: number;
     longitude: number;
@@ -53,11 +57,17 @@ export declare function exactKey<R>(extract: (record: R) => string | null | unde
  * Tighter blocks, lower recall — use when a single rule is too loose.
  */
 export declare function conjunction<R>(...keys: BlockingKey<R>[]): BlockingKey<R>;
-/** The outcome of a blocking pass. */
+/**
+ * The outcome of a blocking pass.
+ */
 export interface BlockResult<R> {
-    /** Deduplicated candidate pairs (no self-pairs; a pair caught by multiple keys appears once). */
+    /**
+     * Deduplicated candidate pairs (no self-pairs; a pair caught by multiple keys appears once).
+     */
     pairs: Array<[R, R]>;
-    /** Blocks that exceeded `maxBlockSize` and were skipped — surfaced so coverage limits are visible. */
+    /**
+     * Blocks that exceeded `maxBlockSize` and were skipped — surfaced so coverage limits are visible.
+     */
     droppedBlocks: Array<{
         key: string;
         size: number;

package/out/blocking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blocking.d.ts","sourceRoot":"","sources":["../blocking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qGAAqG;AACrG,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,EAAE,CAAA;AAEpD,uDAAuD;AACvD,MAAM,WAAW,MAAM;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC3B,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,IAAI,GAAE;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,WAAW,CAAC,CAAC,CAAC,CAwBhB;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACzB,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CAAO,GACnE,WAAW,CAAC,CAAC,CAAC,CAahB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,CAaxE;AAED,sCAAsC;AACtC,MAAM,WAAW,WAAW,CAAC,CAAC;IAC7B,iGAAiG;IACjG,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACpB,sGAAsG;IACtG,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACnD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACtB,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,EAC/C,IAAI,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,WAAW,CAAC,CAAC,CAAC,CAkDhB"}
+{"version":3,"file":"blocking.d.ts","sourceRoot":"","sources":["../blocking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,EAAE,CAAA;AAEpD;;GAEG;AACH,MAAM,WAAW,MAAM;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC3B,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,IAAI,GAAE;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,WAAW,CAAC,CAAC,CAAC,CAwBhB;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACzB,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CAAO,GACnE,WAAW,CAAC,CAAC,CAAC,CAahB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,CAaxE;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC7B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACpB;;OAEG;IACH,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACnD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACtB,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,EAC/C,IAAI,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,WAAW,CAAC,CAAC,CAAC,CAmDhB"}

package/out/blocking.js

@@ -53,7 +53,7 @@ export function geoCellKey(extract, opts = {}) {
  * key.
  */
 export function exactKey(extract, opts = {}) {
-    const normalize = opts.normalize ?? ((v) => v.trim().toLowerCase().replace(/\s+/g, " "));
+    const normalize = opts.normalize ?? ((v) => v.trim().toLowerCase().replaceAll(/\s+/g, " "));
     return (record) => {
         const value = extract(record);
         if (!value)
@@ -74,7 +74,7 @@ export function conjunction(...keys) {
         let combos = [""];
         for (const key of keys) {
             const parts = key(record);
-            if (parts.length === 0)
+            if (!parts.length)
                 return [];
             combos = combos.flatMap((prefix) => parts.map((part) => (prefix ? `${prefix}&${part}` : part)));
         }