typescript-dsa-stl 2.0.2 → 2.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 **This is the GitHub repository** for the npm package **[typescript-dsa-stl](https://www.npmjs.com/package/typescript-dsa-stl)**.
 
-STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**, **Queue**, **List**, **PriorityQueue**, **OrderedMap** (Map), **UnorderedMap**, **OrderedSet** (Set), **UnorderedSet**, **OrderedMultiMap**, **OrderedMultiSet**, and algorithms (`sort`, `binarySearch`, `lowerBound`, `min`, `max`, etc.). Install from npm to use in your project; this repo holds the source code.
+STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**, **Queue**, **List**, **PriorityQueue**, **OrderedMap** (Map), **UnorderedMap**, **OrderedSet** (Set), **UnorderedSet**, **OrderedMultiMap**, **OrderedMultiSet**, and algorithms (`sort`, `binarySearch`, `lowerBound`, `min`, `max`, **KnuthMorrisPratt**, **RabinKarp**, **StringRollingHash**, etc.). Install from npm to use in your project; this repo holds the source code.
 
 ---
 
@@ -236,6 +236,193 @@ Use an **unweighted** graph (adjacency list) when you only care about connectivi
 | **Grid / game graphs** | Unweighted: 4- or 8-neighbor grids; weighted if movement costs differ per cell. |
 | **Network / flow** | Weighted: capacities or latencies on edges for max-flow or routing. |
 
+#### Disjoint Set Union (Union-Find)
+
+Use Union-Find (DSU) to compute connected components efficiently. It merges endpoints of every edge in the adjacency list, so for directed graphs it returns weak connectivity components.
+
+```ts
+import { createAdjacencyList, connectedComponents } from 'typescript-dsa-stl';
+
+const n = 5;
+const graph = createAdjacencyList(n);
+graph[0].push(1);
+graph[1].push(0);
+graph[3].push(4);
+graph[4].push(3);
+
+const comps = connectedComponents(n, graph);
+// e.g. [[0, 1], [2], [3, 4]]
+```
+
+##### Traverse the result
+
+`connectedComponents(n, adj)` returns `number[][]` where each inner array is a component (list of vertices).
+
+```ts
+// 1) Iterate each component
+for (const comp of comps) {
+  // comp is like [v0, v1, ...]
+  for (const v of comp) {
+    // do something with vertex v
+  }
+}
+
+// 2) Component sizes
+const sizes = comps.map(comp => comp.length);
+```
+
+#### Kruskal MST (uses DSU)
+
+For a weighted graph, `kruskalMST` builds a Minimum Spanning Tree (MST) using DSU.
+
+```ts
+import {
+  createWeightedAdjacencyList,
+  addEdge,
+  kruskalMST,
+} from 'typescript-dsa-stl';
+
+const n = 4;
+const wGraph = createWeightedAdjacencyList(n);
+
+// Add undirected edges by adding both directions.
+addEdge(wGraph, 0, 1, 1); addEdge(wGraph, 1, 0, 1);
+addEdge(wGraph, 0, 2, 4); addEdge(wGraph, 2, 0, 4);
+addEdge(wGraph, 1, 2, 2); addEdge(wGraph, 2, 1, 2);
+addEdge(wGraph, 1, 3, 3); addEdge(wGraph, 3, 1, 3);
+
+const { edges, totalWeight } = kruskalMST(n, wGraph, { undirected: true });
+// edges: MST edges (chosen by weight), totalWeight: sum of weights
+```
+
+##### Traverse the MST
+
+`kruskalMST(...)` returns `{ edges, totalWeight }`. To traverse the MST like a graph, convert `edges` into an adjacency list:
+
+```ts
+import { createWeightedAdjacencyList } from 'typescript-dsa-stl/collections';
+
+const mstAdj = createWeightedAdjacencyList(n);
+
+for (const { u, v, weight } of edges) {
+  // MST is undirected (we used { undirected: true })
+  mstAdj[u].push({ to: v, weight });
+  mstAdj[v].push({ to: u, weight });
+}
+
+// Example: iterate neighbors of vertex 0 in the MST
+for (const { to, weight } of mstAdj[0]) {
+  // visit edge 0 -> to (weight)
+}
+```
+
+#### Knuth–Morris–Pratt (KMP), Rabin–Karp, and string rolling hash
+
+All three work on **UTF-16 code units** (same as `String` indexing). They solve **different jobs**: KMP and Rabin–Karp are **pattern matchers** (list all start indices of a pattern in a text). `StringRollingHash` is a **substring-hash tool** on a **fixed** string—you combine it with your own logic (equality checks, binary search, etc.).
+
+##### When to use which
+
+| Goal | Prefer | Why |
+|------|--------|-----|
+| **Find every occurrence** of **one pattern** in **one text**, with **worst-case** O(n + m), **no hashing**, predictable behaviour | **KnuthMorrisPratt** | LPS table; only character comparisons; no modular arithmetic. |
+| **Find every occurrence** of a pattern using a **sliding window** and **hashes** (triple moduli + final verify) | **RabinKarp** | Same asymptotic average case; good when you think in rolling hashes or batch **same-length** patterns. |
+| **Many O(1) hash queries** on **substrings of one string** you already hold (compare two ranges, palindrome / LCP style checks, rolling checks without slicing) | **StringRollingHash** | O(n) preprocess, O(1) per `substringHash`; **not** a drop-in “find all matches” API—use KMP or Rabin–Karp for that. |
+
+**Concrete situations**
+
+- **Use KMP** when you need a **guaranteed** linear scan (interviews, strict time bounds, large alphabets), or the pattern is **reused** across many searches (`new KnuthMorrisPratt(pattern)` once, `.search(text)` many times).
+- **Use Rabin–Karp** when a **rolling hash** model fits (e.g. one long stream, one pattern), or you later generalize to **several patterns of the same length** (compare each pattern’s triple hash to each window hash). Triple hashing keeps false hash positives negligible; **verification** still guarantees correct indices.
+- **Use `StringRollingHash`** when the problem is **“hash of s[l..r)”** many times on **one** `s`—e.g. check `s[i..i+k) === s[j..j+k)` via hash equality (then confirm if needed), or algorithms that **binary search** on length using substring hashes. For **only** “list all starts of P in T”, pick **KMP** or **Rabin–Karp** instead of building substring hashes by hand.
+
+```ts
+import { KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl';
+
+// A) Pattern fixed, searched in many buffers — build KMP once, call .search() repeatedly (LPS reused).
+const multiDoc = new KnuthMorrisPratt('ERROR');
+multiDoc.search(serverLog1);
+multiDoc.search(serverLog2);
+
+// B) One haystack, one needle — both matchers return the same indices; KMP = no mods, Rabin–Karp = triple hash + verify.
+const hay = '...long text...';
+KnuthMorrisPratt.findOccurrences(hay, 'needle');
+new RabinKarp('needle').search(hay);
+
+// C) Same static string, many range-equality checks — rolling hash (not for “find all pattern starts” by itself).
+const s = 'banana';
+const rh = new StringRollingHash(s);
+// Does s[1..4) equal s[3..6)? (both length 3)
+const maybe = rh.substringHash(1, 3) === rh.substringHash(3, 3); // then compare slices if you need certainty
+```
+
+**How KMP works:** Build an LPS (longest proper prefix that is also a suffix) table for the pattern, then scan the text once. On a mismatch, the LPS tells you how far to shift the pattern without moving the text pointer backward—**O(n + m)** time, **O(m)** extra space for the pattern’s LPS.
+
+**How Rabin–Karp works:** Use **triple hashing**—three independent polynomial hashes (same base, three distinct prime moduli, see `RABIN_KARP_DEFAULT_MODS`). A position is a candidate only when **all three** window hashes match the pattern’s triple; then a **character-by-character** check runs so reported matches are always correct. Spurious triple collisions are negligible; average **O(n + m)**.
+
+**How rolling hash works:** Precompute prefix hashes and powers of a base modulo a prime. The hash of any substring `s[start .. start + length)` is derived from two prefix values—**O(n)** build, **O(1)** per substring query. Hashes can collide; for critical equality checks, compare actual strings after a hash match.
+
+```ts
+import {
+  KnuthMorrisPratt,
+  StringRollingHash,
+  RabinKarp,
+  RABIN_KARP_DEFAULT_MODS,
+} from 'typescript-dsa-stl';
+
+// --- KMP: construct with the pattern; LPS is built inside the constructor ---
+const kmp = new KnuthMorrisPratt('aba');
+// LPS for "aba" is [0, 0, 1] — used to skip redundant comparisons after a partial match
+
+const positions = kmp.search('ababa');
+// "aba" appears starting at index 0 ("ababa") and index 2 ("aba" at the end)
+console.log(positions); // [0, 2]
+
+// One-shot search without storing an instance (same result as above for this pattern/text)
+console.log(KnuthMorrisPratt.findOccurrences('ababa', 'aba')); // [0, 2]
+
+// Overlapping matches are all reported (each valid start index)
+const overlaps = KnuthMorrisPratt.findOccurrences('aaaa', 'aa');
+// Starts at 0, 1, 2 — three overlapping occurrences of "aa"
+console.log(overlaps); // [0, 1, 2]
+
+// Empty pattern: no matches returned (empty array)
+console.log(new KnuthMorrisPratt('').search('anything')); // []
+
+// --- Rabin–Karp: triple moduli (defaults) + verification; same results as KMP for real matches ---
+const rk = new RabinKarp('aba');
+// RABIN_KARP_DEFAULT_MODS = [1e9+7, 1e9+9, 998244353] — three hashes must agree, then verify
+console.log(RABIN_KARP_DEFAULT_MODS.length); // 3
+console.log(rk.search('ababa')); // [0, 2]
+console.log(RabinKarp.findOccurrences('ababa', 'aba')); // [0, 2]
+// new RabinKarp(pattern, base?, [mod0, mod1, mod2]) — override the three primes if needed
+
+// Overlapping matches (same as KMP)
+console.log(RabinKarp.findOccurrences('aaaa', 'aa')); // [0, 1, 2]
+
+// Empty pattern: no matches
+console.log(new RabinKarp('').search('text')); // []
+
+// --- String rolling hash: default base 131, mod 1_000_000_007 (both configurable) ---
+const rh = new StringRollingHash('hello');
+// Internally: prefix[] and pow[] so substring hashes are O(1)
+
+// Hash of the entire string (same as substring from 0 with full length)
+console.log(rh.fullHash()); // bigint — concrete value depends on base/mod
+console.log(rh.substringHash(0, rh.length())); // same bigint as fullHash()
+
+// Hash of substring "ell" — starts at index 1, length 3
+console.log(rh.substringHash(1, 3)); // bigint for "ell"
+
+// Two equal strings with the same base/mod yield equal full hashes
+const same = new StringRollingHash('hello');
+console.log(rh.fullHash() === same.fullHash()); // true
+
+// Compare a substring of one string to another range (useful for pattern checks)
+const a = new StringRollingHash('banana');
+const b = new StringRollingHash('na');
+// Hash of "na" in "banana" at index 2 should match b’s full hash if substrings equal
+console.log(a.substringHash(2, 2) === b.fullHash()); // true — both are "na"
+```
+
 ---
 
 ## API overview
@@ -243,15 +430,15 @@ Use an **unweighted** graph (adjacency list) when you only care about connectivi
 | Module | Exports |
 |--------|--------|
 | **Collections** | `Vector`, `Stack`, `Queue`, `List`, `ListNode`, `PriorityQueue`, `OrderedMap`, `UnorderedMap`, `OrderedSet`, `UnorderedSet`, `OrderedMultiMap`, `OrderedMultiSet`, `WeightedEdge`, `AdjacencyList`, `WeightedAdjacencyList`, `createAdjacencyList`, `createWeightedAdjacencyList`, `addEdge`, `deleteEdge` |
-| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition` |
+| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition`, `DisjointSetUnion`, `KnuthMorrisPratt`, `RabinKarp`, `RABIN_KARP_DEFAULT_MODS`, `StringRollingHash`, `connectedComponents`, `kruskalMST` |
 | **Utils** | `clamp`, `range`, `noop`, `identity`, `swap` |
-| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray` |
+| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray`, `RabinKarpTripleMods` |
 
 ### Subpath imports (tree-shaking)
 
 ```ts
 import { Vector, Stack } from 'typescript-dsa-stl/collections';
-import { sort, binarySearch } from 'typescript-dsa-stl/algorithms';
+import { sort, binarySearch, KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl/algorithms';
 import { clamp, range } from 'typescript-dsa-stl/utils';
 import type { Comparator } from 'typescript-dsa-stl/types';
 ```

package/dist/algorithms/disjointSetUnion.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Disjoint Set Union (Union-Find) with:
+ * - Path compression (iterative)
+ * - Union by size
+ *
+ * Optimized for vertex indices in range [0..n-1].
+ */
+export declare class DisjointSetUnion {
+    private readonly parent;
+    private readonly size;
+    constructor(n: number);
+    /**
+     * Find the representative(root) of x.
+     * Amortized almost O(1) with path compression.
+     */
+    find(x: number): number;
+    /** Returns true if a merge happened (were in different sets). */
+    union(a: number, b: number): boolean;
+    connected(a: number, b: number): boolean;
+    /** Size of the connected component containing x. */
+    componentSize(x: number): number;
+    /**
+     * Get component representative id for each vertex.
+     * Runs `find(i)` for each i (so it also compresses paths).
+     */
+    roots(): Int32Array;
+    /**
+     * Group vertices into components.
+     * Complexity: O(n * alpha(n)).
+     */
+    components(nVertices?: number): number[][];
+}
+//# sourceMappingURL=disjointSetUnion.d.ts.map

package/dist/algorithms/disjointSetUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disjointSetUnion.d.ts","sourceRoot":"","sources":["../../src/algorithms/disjointSetUnion.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;gBAEtB,CAAC,EAAE,MAAM;IAUrB;;;OAGG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAiBvB,iEAAiE;IACjE,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAiBpC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAIxC,oDAAoD;IACpD,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAIhC;;;OAGG;IACH,KAAK,IAAI,UAAU;IAQnB;;;OAGG;IACH,UAAU,CAAC,SAAS,SAAqB,GAAG,MAAM,EAAE,EAAE;CAqBvD"}

package/dist/algorithms/disjointSetUnion.js

@@ -0,0 +1,93 @@
+/**
+ * Disjoint Set Union (Union-Find) with:
+ * - Path compression (iterative)
+ * - Union by size
+ *
+ * Optimized for vertex indices in range [0..n-1].
+ */
+export class DisjointSetUnion {
+    constructor(n) {
+        // Assumes valid vertex count and indices are provided by the caller.
+        this.parent = new Int32Array(n);
+        this.size = new Int32Array(n);
+        for (let i = 0; i < n; i++) {
+            this.parent[i] = i;
+            this.size[i] = 1;
+        }
+    }
+    /**
+     * Find the representative(root) of x.
+     * Amortized almost O(1) with path compression.
+     */
+    find(x) {
+        // Find root.
+        let root = x;
+        while (this.parent[root] !== root) {
+            root = this.parent[root];
+        }
+        // Compress path.
+        while (this.parent[x] !== x) {
+            const p = this.parent[x];
+            this.parent[x] = root;
+            x = p;
+        }
+        return root;
+    }
+    /** Returns true if a merge happened (were in different sets). */
+    union(a, b) {
+        let ra = this.find(a);
+        let rb = this.find(b);
+        if (ra === rb)
+            return false;
+        // Union by size: attach smaller tree under larger tree.
+        if (this.size[ra] < this.size[rb]) {
+            const tmp = ra;
+            ra = rb;
+            rb = tmp;
+        }
+        this.parent[rb] = ra;
+        this.size[ra] += this.size[rb];
+        return true;
+    }
+    connected(a, b) {
+        return this.find(a) === this.find(b);
+    }
+    /** Size of the connected component containing x. */
+    componentSize(x) {
+        return this.size[this.find(x)];
+    }
+    /**
+     * Get component representative id for each vertex.
+     * Runs `find(i)` for each i (so it also compresses paths).
+     */
+    roots() {
+        const out = new Int32Array(this.parent.length);
+        for (let i = 0; i < out.length; i++) {
+            out[i] = this.find(i);
+        }
+        return out;
+    }
+    /**
+     * Group vertices into components.
+     * Complexity: O(n * alpha(n)).
+     */
+    components(nVertices = this.parent.length) {
+        // Use an array lookup instead of Map for faster grouping.
+        const rootToIndex = new Int32Array(this.parent.length);
+        rootToIndex.fill(-1);
+        const groups = [];
+        const n = Math.min(nVertices, this.parent.length);
+        for (let i = 0; i < n; i++) {
+            const r = this.find(i);
+            let idx = rootToIndex[r];
+            if (idx === -1) {
+                idx = groups.length;
+                rootToIndex[r] = idx;
+                groups.push([]);
+            }
+            groups[idx].push(i);
+        }
+        return groups;
+    }
+}
+//# sourceMappingURL=disjointSetUnion.js.map

package/dist/algorithms/disjointSetUnion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disjointSetUnion.js","sourceRoot":"","sources":["../../src/algorithms/disjointSetUnion.ts"],"names":[],"mappings":"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"}

package/dist/algorithms/graph.d.ts

@@ -0,0 +1,29 @@
+import type { AdjacencyList, WeightedAdjacencyList } from '../collections/index.js';
+export interface WeightedUndirectedEdge {
+    u: number;
+    v: number;
+    weight: number;
+}
+/**
+ * Connected components in an (unweighted) graph using DSU.
+ * Complexity: O((n + m) * alpha(n)).
+ *
+ * Notes:
+ * - Assumes vertices are numbered `0..n-1`.
+ * - If your adjacency list stores each edge once or twice, DSU will still work.
+ */
+export declare function connectedComponents(n: number, adj: AdjacencyList<number>): number[][];
+/**
+ * Kruskal's algorithm for Minimum Spanning Tree (MST) using DSU.
+ *
+ * Complexity: O(m log m) for sorting edges + O(m * alpha(n)).
+ *
+ * @returns a spanning forest if the graph is disconnected.
+ */
+export declare function kruskalMST(n: number, adj: WeightedAdjacencyList<number, number>, options?: {
+    undirected?: boolean;
+}): {
+    edges: WeightedUndirectedEdge[];
+    totalWeight: number;
+};
+//# sourceMappingURL=graph.d.ts.map

package/dist/algorithms/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAGpF,MAAM,WAAW,sBAAsB;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,MAAM,EAAE,EAAE,CAQZ;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAgC1D"}

package/dist/algorithms/graph.js

@@ -0,0 +1,57 @@
+import { DisjointSetUnion } from './disjointSetUnion.js';
+/**
+ * Connected components in an (unweighted) graph using DSU.
+ * Complexity: O((n + m) * alpha(n)).
+ *
+ * Notes:
+ * - Assumes vertices are numbered `0..n-1`.
+ * - If your adjacency list stores each edge once or twice, DSU will still work.
+ */
+export function connectedComponents(n, adj) {
+    const dsu = new DisjointSetUnion(n);
+    for (let u = 0; u < n; u++) {
+        for (const v of adj[u] ?? []) {
+            dsu.union(u, v);
+        }
+    }
+    return dsu.components(n);
+}
+/**
+ * Kruskal's algorithm for Minimum Spanning Tree (MST) using DSU.
+ *
+ * Complexity: O(m log m) for sorting edges + O(m * alpha(n)).
+ *
+ * @returns a spanning forest if the graph is disconnected.
+ */
+export function kruskalMST(n, adj, options) {
+    const undirected = options?.undirected ?? true;
+    // Extract edges from adjacency list.
+    // For undirected graphs represented as both-direction adjacency,
+    // take only u < v to avoid duplicates.
+    const edges = [];
+    for (let u = 0; u < n; u++) {
+        for (const { to: v, weight } of adj[u] ?? []) {
+            if (undirected) {
+                if (u < v)
+                    edges.push({ u, v, weight });
+            }
+            else {
+                edges.push({ u, v, weight });
+            }
+        }
+    }
+    edges.sort((a, b) => a.weight - b.weight);
+    const dsu = new DisjointSetUnion(n);
+    const mstEdges = [];
+    let totalWeight = 0;
+    for (const e of edges) {
+        if (dsu.union(e.u, e.v)) {
+            mstEdges.push(e);
+            totalWeight += e.weight;
+            if (mstEdges.length === n - 1)
+                break; // MST complete for connected graphs.
+        }
+    }
+    return { edges: mstEdges, totalWeight };
+}
+//# sourceMappingURL=graph.js.map

package/dist/algorithms/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAQzD;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CACjC,CAAS,EACT,GAA0B;IAE1B,MAAM,GAAG,GAAG,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YAC7B,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CACxB,CAAS,EACT,GAA0C,EAC1C,OAAkC;IAElC,MAAM,UAAU,GAAG,OAAO,EAAE,UAAU,IAAI,IAAI,CAAC;IAE/C,qCAAqC;IACrC,iEAAiE;IACjE,uCAAuC;IACvC,MAAM,KAAK,GAA6B,EAAE,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,KAAK,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YAC7C,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,CAAC,GAAG,CAAC;oBAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAC1C,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;IAE1C,MAAM,GAAG,GAAG,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACpC,MAAM,QAAQ,GAA6B,EAAE,CAAC;IAC9C,IAAI,WAAW,GAAG,CAAC,CAAC;IAEpB,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,WAAW,IAAI,CAAC,CAAC,MAAM,CAAC;YACxB,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,GAAG,CAAC;gBAAE,MAAM,CAAC,qCAAqC;QAC7E,CAAC;IACH,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;AAC1C,CAAC"}

package/dist/algorithms/index.d.ts

@@ -1,2 +1,9 @@
 export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, } from './array.js';
+export { DisjointSetUnion } from './disjointSetUnion.js';
+export { KnuthMorrisPratt } from './kmp.js';
+export { StringRollingHash } from './stringHashing.js';
+export { RabinKarp, RABIN_KARP_DEFAULT_MODS } from './rabinKarp.js';
+export type { RabinKarpTripleMods } from './rabinKarp.js';
+export type { WeightedUndirectedEdge } from './graph.js';
+export { connectedComponents, kruskalMST } from './graph.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/algorithms/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/algorithms/index.js

@@ -1,2 +1,7 @@
 export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, } from './array.js';
+export { DisjointSetUnion } from './disjointSetUnion.js';
+export { KnuthMorrisPratt } from './kmp.js';
+export { StringRollingHash } from './stringHashing.js';
+export { RabinKarp, RABIN_KARP_DEFAULT_MODS } from './rabinKarp.js';
+export { connectedComponents, kruskalMST } from './graph.js';
 //# sourceMappingURL=index.js.map

package/dist/algorithms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAGpE,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/algorithms/kmp.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Knuth–Morris–Pratt (KMP) string matching.
+ * Precomputes the LPS (longest proper prefix which is also suffix) table for the pattern,
+ * then scans text in O(n + m) time.
+ */
+export declare class KnuthMorrisPratt {
+    private readonly pattern;
+    private readonly lps;
+    constructor(pattern: string);
+    /** LPS array: lps[i] = length of longest proper prefix of pattern[0..i] that is also a suffix. */
+    static buildLps(pattern: string): number[];
+    /**
+     * All start indices in `text` where `this.pattern` occurs.
+     * Empty pattern yields no matches.
+     */
+    search(text: string): number[];
+    /** One-shot: all occurrences of `pattern` in `text`. */
+    static findOccurrences(text: string, pattern: string): number[];
+}
+//# sourceMappingURL=kmp.d.ts.map

package/dist/algorithms/kmp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kmp.d.ts","sourceRoot":"","sources":["../../src/algorithms/kmp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAW;gBAEnB,OAAO,EAAE,MAAM;IAK3B,kGAAkG;IAClG,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAoB1C;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IA8B9B,wDAAwD;IACxD,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;CAGhE"}

package/dist/algorithms/kmp.js

@@ -0,0 +1,70 @@
+/**
+ * Knuth–Morris–Pratt (KMP) string matching.
+ * Precomputes the LPS (longest proper prefix which is also suffix) table for the pattern,
+ * then scans text in O(n + m) time.
+ */
+export class KnuthMorrisPratt {
+    constructor(pattern) {
+        this.pattern = pattern;
+        this.lps = KnuthMorrisPratt.buildLps(pattern);
+    }
+    /** LPS array: lps[i] = length of longest proper prefix of pattern[0..i] that is also a suffix. */
+    static buildLps(pattern) {
+        const m = pattern.length;
+        const lps = new Array(m).fill(0);
+        let len = 0;
+        let i = 1;
+        while (i < m) {
+            if (pattern[i] === pattern[len]) {
+                len++;
+                lps[i] = len;
+                i++;
+            }
+            else if (len !== 0) {
+                len = lps[len - 1];
+            }
+            else {
+                lps[i] = 0;
+                i++;
+            }
+        }
+        return lps;
+    }
+    /**
+     * All start indices in `text` where `this.pattern` occurs.
+     * Empty pattern yields no matches.
+     */
+    search(text) {
+        const m = this.pattern.length;
+        if (m === 0)
+            return [];
+        const n = text.length;
+        const matches = [];
+        let i = 0;
+        let j = 0;
+        while (i < n) {
+            if (text[i] === this.pattern[j]) {
+                i++;
+                j++;
+            }
+            if (j === m) {
+                matches.push(i - j);
+                j = this.lps[j - 1];
+            }
+            else if (i < n && text[i] !== this.pattern[j]) {
+                if (j !== 0) {
+                    j = this.lps[j - 1];
+                }
+                else {
+                    i++;
+                }
+            }
+        }
+        return matches;
+    }
+    /** One-shot: all occurrences of `pattern` in `text`. */
+    static findOccurrences(text, pattern) {
+        return new KnuthMorrisPratt(pattern).search(text);
+    }
+}
+//# sourceMappingURL=kmp.js.map

package/dist/algorithms/kmp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kmp.js","sourceRoot":"","sources":["../../src/algorithms/kmp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,OAAO,gBAAgB;IAI3B,YAAY,OAAe;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,GAAG,GAAG,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,kGAAkG;IAClG,MAAM,CAAC,QAAQ,CAAC,OAAe;QAC7B,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;QACzB,MAAM,GAAG,GAAG,IAAI,KAAK,CAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACb,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBAChC,GAAG,EAAE,CAAC;gBACN,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;gBACb,CAAC,EAAE,CAAC;YACN,CAAC;iBAAM,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC;gBACrB,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAE,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBACX,CAAC,EAAE,CAAC;YACN,CAAC;QACH,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,IAAY;QACjB,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAEvB,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QACtB,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,IAAI,CAAC,GAAG,CAAC,CAAC;QAEV,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACb,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;gBAChC,CAAC,EAAE,CAAC;gBACJ,CAAC,EAAE,CAAC;YACN,CAAC;YAED,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACZ,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACpB,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAE,CAAC;YACvB,CAAC;iBAAM,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;gBAChD,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oBACZ,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAE,CAAC;gBACvB,CAAC;qBAAM,CAAC;oBACN,CAAC,EAAE,CAAC;gBACN,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,wDAAwD;IACxD,MAAM,CAAC,eAAe,CAAC,IAAY,EAAE,OAAe;QAClD,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACpD,CAAC;CACF"}

package/dist/algorithms/rabinKarp.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Rabin–Karp string matching with **triple hashing**: three independent polynomial hashes
+ * (same base, distinct prime moduli). A window is a candidate only when all three hashes
+ * match the pattern’s triple—collision probability is negligible; we still verify with a
+ * direct character comparison so results are always correct.
+ */
+/** Default moduli: distinct large primes (common CP / hashing choices). */
+export declare const RABIN_KARP_DEFAULT_MODS: readonly [1000000007n, 1000000009n, 998244353n];
+export type RabinKarpTripleMods = readonly [bigint, bigint, bigint];
+export declare class RabinKarp {
+    private readonly pattern;
+    private readonly base;
+    private readonly mods;
+    /**
+     * @param pattern Pattern to search for (UTF-16 code units, same as `charCodeAt`).
+     * @param base Shared radix (default 131), same idea as `StringRollingHash`.
+     * @param mods Three distinct prime moduli for independent rolling hashes.
+     */
+    constructor(pattern: string, base?: bigint, mods?: RabinKarpTripleMods);
+    private static substringsEqual;
+    /** Iterative hash of `s[0..length)` for each modulus. */
+    private hashPrefix;
+    /** `base^(m-1) mod mods[j]` for sliding the left character out of the window. */
+    private powHighForWindow;
+    private slideWindow;
+    private triplesEqual;
+    /**
+     * All start indices in `text` where `this.pattern` occurs.
+     * Empty pattern yields no matches.
+     */
+    search(text: string): number[];
+    /** One-shot: all occurrences of `pattern` in `text`. */
+    static findOccurrences(text: string, pattern: string, base?: bigint, mods?: RabinKarpTripleMods): number[];
+}
+//# sourceMappingURL=rabinKarp.d.ts.map

package/dist/algorithms/rabinKarp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabinKarp.d.ts","sourceRoot":"","sources":["../../src/algorithms/rabinKarp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,iDAI1B,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpE,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAE3C;;;;OAIG;gBAED,OAAO,EAAE,MAAM,EACf,IAAI,SAAO,EACX,IAAI,GAAE,mBAA6C;IAerD,OAAO,CAAC,MAAM,CAAC,eAAe;IAY9B,yDAAyD;IACzD,OAAO,CAAC,UAAU;IAYlB,iFAAiF;IACjF,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,YAAY;IAIpB;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IA4B9B,wDAAwD;IACxD,MAAM,CAAC,eAAe,CACpB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,SAAO,EACX,IAAI,GAAE,mBAA6C,GAClD,MAAM,EAAE;CAGZ"}

package/dist/algorithms/rabinKarp.js

@@ -0,0 +1,119 @@
+/**
+ * Rabin–Karp string matching with **triple hashing**: three independent polynomial hashes
+ * (same base, distinct prime moduli). A window is a candidate only when all three hashes
+ * match the pattern’s triple—collision probability is negligible; we still verify with a
+ * direct character comparison so results are always correct.
+ */
+function modNormalize(value, mod) {
+    let x = value % mod;
+    if (x < 0n)
+        x += mod;
+    return x;
+}
+/** Default moduli: distinct large primes (common CP / hashing choices). */
+export const RABIN_KARP_DEFAULT_MODS = [
+    1000000007n,
+    1000000009n,
+    998244353n,
+];
+export class RabinKarp {
+    /**
+     * @param pattern Pattern to search for (UTF-16 code units, same as `charCodeAt`).
+     * @param base Shared radix (default 131), same idea as `StringRollingHash`.
+     * @param mods Three distinct prime moduli for independent rolling hashes.
+     */
+    constructor(pattern, base = 131n, mods = RABIN_KARP_DEFAULT_MODS) {
+        if (base <= 0n) {
+            throw new RangeError('base must be positive');
+        }
+        for (let j = 0; j < 3; j++) {
+            if (mods[j] <= 0n) {
+                throw new RangeError('each mod must be positive');
+            }
+        }
+        this.pattern = pattern;
+        this.base = base;
+        this.mods = mods;
+    }
+    static substringsEqual(text, start, pattern, length) {
+        for (let k = 0; k < length; k++) {
+            if (text[start + k] !== pattern[k])
+                return false;
+        }
+        return true;
+    }
+    /** Iterative hash of `s[0..length)` for each modulus. */
+    hashPrefix(s, length) {
+        const h = [0n, 0n, 0n];
+        const { base, mods } = this;
+        for (let i = 0; i < length; i++) {
+            const c = BigInt(s.charCodeAt(i));
+            for (let j = 0; j < 3; j++) {
+                h[j] = modNormalize(h[j] * base + c, mods[j]);
+            }
+        }
+        return h;
+    }
+    /** `base^(m-1) mod mods[j]` for sliding the left character out of the window. */
+    powHighForWindow(m) {
+        const out = [1n, 1n, 1n];
+        const { base, mods } = this;
+        for (let j = 0; j < 3; j++) {
+            let p = 1n;
+            const mod = mods[j];
+            for (let i = 0; i < m - 1; i++) {
+                p = modNormalize(p * base, mod);
+            }
+            out[j] = p;
+        }
+        return out;
+    }
+    slideWindow(window, left, right, powHigh) {
+        const next = [0n, 0n, 0n];
+        const { base, mods } = this;
+        for (let j = 0; j < 3; j++) {
+            const mod = mods[j];
+            const w = window[j];
+            const ph = powHigh[j];
+            next[j] = modNormalize(modNormalize(w - modNormalize(left * ph, mod), mod) * base + right, mod);
+        }
+        return next;
+    }
+    triplesEqual(a, b) {
+        return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+    }
+    /**
+     * All start indices in `text` where `this.pattern` occurs.
+     * Empty pattern yields no matches.
+     */
+    search(text) {
+        const pat = this.pattern;
+        const m = pat.length;
+        const n = text.length;
+        if (m === 0)
+            return [];
+        if (m > n)
+            return [];
+        const patHash = this.hashPrefix(pat, m);
+        let windowHash = this.hashPrefix(text, m);
+        const powHigh = this.powHighForWindow(m);
+        const matches = [];
+        for (let i = 0; i <= n - m; i++) {
+            if (this.triplesEqual(windowHash, patHash) &&
+                RabinKarp.substringsEqual(text, i, pat, m)) {
+                matches.push(i);
+            }
+            if (i + m >= n)
+                break;
+            const left = BigInt(text.charCodeAt(i));
+            const right = BigInt(text.charCodeAt(i + m));
+            windowHash = this.slideWindow(windowHash, left, right, powHigh);
+        }
+        return matches;
+    }
+    /** One-shot: all occurrences of `pattern` in `text`. */
+    static findOccurrences(text, pattern, base = 131n, mods = RABIN_KARP_DEFAULT_MODS) {
+        return new RabinKarp(pattern, base, mods).search(text);
+    }
+}
+//# sourceMappingURL=rabinKarp.js.map

package/dist/algorithms/rabinKarp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabinKarp.js","sourceRoot":"","sources":["../../src/algorithms/rabinKarp.ts"],"names":[],"mappings":"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"}

package/dist/algorithms/stringHashing.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Polynomial rolling hash on a string: prefix hashes and powers of base
+ * support O(1) substring hash queries after O(n) preprocessing.
+ */
+export declare class StringRollingHash {
+    private readonly n;
+    private readonly base;
+    private readonly mod;
+    private readonly prefix;
+    private readonly pow;
+    /**
+     * @param s Source string (UTF-16 code units, same as `charCodeAt`).
+     * @param base Must be positive and coprime to `mod` for typical use.
+     * @param mod Prime modulus (e.g. 1_000_000_007n).
+     */
+    constructor(s: string, base?: bigint, mod?: bigint);
+    /** Full string hash (same as substringHash(0, length)). */
+    fullHash(): bigint;
+    /**
+     * Hash of `s.substring(start, start + length)` using the configured base and mod.
+     * Indices are in [0, n); `length` must be non-negative and `start + length <= n`.
+     */
+    substringHash(start: number, length: number): bigint;
+    /** Underlying string length. */
+    length(): number;
+}
+//# sourceMappingURL=stringHashing.d.ts.map

package/dist/algorithms/stringHashing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringHashing.d.ts","sourceRoot":"","sources":["../../src/algorithms/stringHashing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAW;IAE/B;;;;OAIG;gBACS,CAAC,EAAE,MAAM,EAAE,IAAI,SAAO,EAAE,GAAG,SAAiB;IAqBxD,2DAA2D;IAC3D,QAAQ,IAAI,MAAM;IAIlB;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAapD,gCAAgC;IAChC,MAAM,IAAI,MAAM;CAGjB"}

package/dist/algorithms/stringHashing.js

@@ -0,0 +1,62 @@
+/**
+ * Polynomial rolling hash on a string: prefix hashes and powers of base
+ * support O(1) substring hash queries after O(n) preprocessing.
+ */
+function modNormalize(value, mod) {
+    let x = value % mod;
+    if (x < 0n)
+        x += mod;
+    return x;
+}
+export class StringRollingHash {
+    /**
+     * @param s Source string (UTF-16 code units, same as `charCodeAt`).
+     * @param base Must be positive and coprime to `mod` for typical use.
+     * @param mod Prime modulus (e.g. 1_000_000_007n).
+     */
+    constructor(s, base = 131n, mod = 1000000007n) {
+        if (mod <= 0n) {
+            throw new RangeError('mod must be positive');
+        }
+        if (base <= 0n) {
+            throw new RangeError('base must be positive');
+        }
+        this.n = s.length;
+        this.base = base;
+        this.mod = mod;
+        this.prefix = new Array(this.n + 1);
+        this.pow = new Array(this.n + 1);
+        this.prefix[0] = 0n;
+        this.pow[0] = 1n;
+        for (let i = 0; i < this.n; i++) {
+            this.pow[i + 1] = modNormalize(this.pow[i] * base, mod);
+            const c = BigInt(s.charCodeAt(i));
+            this.prefix[i + 1] = modNormalize(this.prefix[i] * base + c, mod);
+        }
+    }
+    /** Full string hash (same as substringHash(0, length)). */
+    fullHash() {
+        return this.prefix[this.n];
+    }
+    /**
+     * Hash of `s.substring(start, start + length)` using the configured base and mod.
+     * Indices are in [0, n); `length` must be non-negative and `start + length <= n`.
+     */
+    substringHash(start, length) {
+        if (length < 0) {
+            throw new RangeError('length must be non-negative');
+        }
+        if (start < 0 || start + length > this.n) {
+            throw new RangeError('substring range out of bounds');
+        }
+        const end = start + length;
+        const high = this.prefix[end];
+        const low = modNormalize(this.prefix[start] * this.pow[length], this.mod);
+        return modNormalize(high - low, this.mod);
+    }
+    /** Underlying string length. */
+    length() {
+        return this.n;
+    }
+}
+//# sourceMappingURL=stringHashing.js.map

package/dist/algorithms/stringHashing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringHashing.js","sourceRoot":"","sources":["../../src/algorithms/stringHashing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,SAAS,YAAY,CAAC,KAAa,EAAE,GAAW;IAC9C,IAAI,CAAC,GAAG,KAAK,GAAG,GAAG,CAAC;IACpB,IAAI,CAAC,GAAG,EAAE;QAAE,CAAC,IAAI,GAAG,CAAC;IACrB,OAAO,CAAC,CAAC;AACX,CAAC;AAED,MAAM,OAAO,iBAAiB;IAO5B;;;;OAIG;IACH,YAAY,CAAS,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,GAAG,WAAc;QACtD,IAAI,GAAG,IAAI,EAAE,EAAE,CAAC;YACd,MAAM,IAAI,UAAU,CAAC,sBAAsB,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,IAAI,IAAI,EAAE,EAAE,CAAC;YACf,MAAM,IAAI,UAAU,CAAC,uBAAuB,CAAC,CAAC;QAChD,CAAC;QACD,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;QAClB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,IAAI,KAAK,CAAS,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5C,IAAI,CAAC,GAAG,GAAG,IAAI,KAAK,CAAS,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACzC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QACpB,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAChC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAE,GAAG,IAAI,EAAE,GAAG,CAAC,CAAC;YACzD,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAE,GAAG,IAAI,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED,2DAA2D;IAC3D,QAAQ;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAE,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,KAAa,EAAE,MAAc;QACzC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;YACf,MAAM,IAAI,UAAU,CAAC,6BAA6B,CAAC,CAAC;QACtD,CAAC;QACD,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,UAAU,CAAC,+BAA+B,CAAC,CAAC;QACxD,CAAC;QACD,MAAM,GAAG,GAAG,KAAK,GAAG,MAAM,CAAC;QAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAE,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5E,OAAO,YAAY,CAAC,IAAI,GAAG,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,gCAAgC;IAChC,MAAM;QACJ,OAAO,IAAI,CAAC,CAAC,CAAC;IAChB,CAAC;CACF"}

package/dist/index.d.ts

@@ -7,7 +7,8 @@
  */
 export { Vector, Stack, Queue, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, } from './collections/index.js';
 export type { WeightedEdge, AdjacencyList, WeightedAdjacencyList } from './collections/index.js';
-export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, } from './algorithms/index.js';
+export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, connectedComponents, kruskalMST, } from './algorithms/index.js';
+export type { WeightedUndirectedEdge, RabinKarpTripleMods } from './algorithms/index.js';
 export { clamp, range, noop, identity, swap } from './utils/index.js';
 export type { Comparator, Predicate, UnaryFn, Reducer, IterableLike } from './types/index.js';
 export { toArray } from './types/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACjG,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACjG,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,mBAAmB,EACnB,UAAU,GACX,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -6,7 +6,7 @@
  * import { Vector, Stack, Queue, List, sort, binarySearch, clamp } from 'typescript-dsa-stl';
  */
 export { Vector, Stack, Queue, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, } from './collections/index.js';
-export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, } from './algorithms/index.js';
+export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, connectedComponents, kruskalMST, } from './algorithms/index.js';
 export { clamp, range, noop, identity, swap } from './utils/index.js';
 export { toArray } from './types/index.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,mBAAmB,EACnB,UAAU,GACX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/package.json

@@ -1,85 +1,85 @@
-{
-  "name": "typescript-dsa-stl",
-  "version": "2.0.2",
-  "description": "STL-style data structures and algorithms for TypeScript: Vector, Stack, Queue, List, PriorityQueue, Map, Set, sort, binarySearch. Use like C++ STL.",
-  "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./collections": {
-      "types": "./dist/collections/index.d.ts",
-      "import": "./dist/collections/index.js",
-      "default": "./dist/collections/index.js"
-    },
-    "./algorithms": {
-      "types": "./dist/algorithms/index.d.ts",
-      "import": "./dist/algorithms/index.js",
-      "default": "./dist/algorithms/index.js"
-    },
-    "./utils": {
-      "types": "./dist/utils/index.d.ts",
-      "import": "./dist/utils/index.js",
-      "default": "./dist/utils/index.js"
-    },
-    "./types": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/types/index.js",
-      "default": "./dist/types/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "typescript",
-    "data-structures",
-    "algorithms",
-    "stl",
-    "dsa",
-    "vector",
-    "stack",
-    "queue",
-    "list",
-    "priority-queue",
-    "map",
-    "set",
-    "ordered-map",
-    "unordered-map",
-    "ordered-multimap",
-    "ordered-multiset",
-    "multimap",
-    "multiset",
-    "binary-search",
-    "collections",
-    "sdk"
-  ],
-  "author": "",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/SajidAbdullah729/TypeScript_DSA.git"
-  },
-  "homepage": "https://github.com/SajidAbdullah729/TypeScript_DSA#readme",
-  "bugs": {
-    "url": "https://github.com/SajidAbdullah729/TypeScript_DSA/issues"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "devDependencies": {
-    "typescript": "^5.3.0"
-  }
-}
+{
+  "name": "typescript-dsa-stl",
+  "version": "2.2.0",
+  "description": "STL-style data structures and algorithms for TypeScript: Vector, Stack, Queue, List, PriorityQueue, Map, Set, sort, binarySearch, graph utilities. Use like C++ STL.",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./collections": {
+      "types": "./dist/collections/index.d.ts",
+      "import": "./dist/collections/index.js",
+      "default": "./dist/collections/index.js"
+    },
+    "./algorithms": {
+      "types": "./dist/algorithms/index.d.ts",
+      "import": "./dist/algorithms/index.js",
+      "default": "./dist/algorithms/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js",
+      "default": "./dist/utils/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "default": "./dist/types/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "typescript",
+    "data-structures",
+    "algorithms",
+    "stl",
+    "dsa",
+    "vector",
+    "stack",
+    "queue",
+    "list",
+    "priority-queue",
+    "map",
+    "set",
+    "ordered-map",
+    "unordered-map",
+    "ordered-multimap",
+    "ordered-multiset",
+    "multimap",
+    "multiset",
+    "binary-search",
+    "collections",
+    "sdk"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SajidAbdullah729/TypeScript_DSA.git"
+  },
+  "homepage": "https://github.com/SajidAbdullah729/TypeScript_DSA#readme",
+  "bugs": {
+    "url": "https://github.com/SajidAbdullah729/TypeScript_DSA/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  }
+}