@stll/text-search 0.2.0 → 0.3.0

package/dist/index-BIQ38WSF.d.ts

@@ -0,0 +1,153 @@
+//#region src/types.d.ts
+/**
+ * A single match result. Same shape as
+ * @stll/regex-set and @stll/aho-corasick.
+ */
+type Match = {
+  /** Index of the pattern that matched. */
+  pattern: number;
+  /** Start UTF-16 code unit offset. */
+  start: number;
+  /** End offset (exclusive). */
+  end: number;
+  /** The matched text. */
+  text: string;
+  /** Pattern name (if provided). */
+  name?: string;
+  /** Edit distance (fuzzy matches only). */
+  distance?: number;
+};
+/** A pattern entry for TextSearch. */
+type PatternEntry = string | RegExp | {
+  pattern: string | RegExp;
+  name?: string;
+} | {
+  pattern: string;
+  name?: string;
+  /** Fuzzy matching distance. Routes to
+   *  @stll/fuzzy-search instead of regex. */
+  distance: number | "auto";
+} | {
+  pattern: string;
+  name?: string;
+  /** Force literal matching via Aho-Corasick.
+   *  Skips regex metacharacter detection so
+   *  patterns like "č.p." or "s.r.o." are
+   *  matched literally, not as regex. */
+  literal: true;
+  /** Per-pattern case-insensitive for AC.
+   *  Overrides the global option for this
+   *  pattern only. */
+  caseInsensitive?: boolean;
+  /** Per-pattern whole-word matching for AC. */
+  wholeWords?: boolean;
+};
+/** Options for TextSearch. */
+type TextSearchOptions = {
+  /**
+   * Use Unicode word boundaries.
+   * @default true
+   */
+  unicodeBoundaries?: boolean;
+  /**
+   * Only match whole words.
+   * @default false
+   */
+  wholeWords?: boolean;
+  /**
+   * Max alternation branches before auto-splitting
+   * into a separate engine instance. Prevents DFA
+   * state explosion when large-alternation patterns
+   * are combined with other patterns.
+   * @default 50
+   */
+  maxAlternations?: number;
+  /**
+   * Fuzzy matching metric.
+   * @default "levenshtein"
+   */
+  fuzzyMetric?: "levenshtein" | "damerau-levenshtein";
+  /**
+   * Normalize diacritics for fuzzy matching.
+   * @default false
+   */
+  normalizeDiacritics?: boolean;
+  /**
+   * Case-insensitive matching for AC literals
+   * and fuzzy patterns.
+   * @default false
+   */
+  caseInsensitive?: boolean;
+  /**
+   * How to handle overlapping matches from
+   * different engines or patterns.
+   *
+   * - "longest": keep longest non-overlapping match
+   *   at each position (default).
+   * - "all": return all matches including overlaps.
+   *   Useful when the caller applies its own dedup.
+   *
+   * @default "longest"
+   */
+  overlapStrategy?: "longest" | "all";
+  /**
+   * Treat ALL string patterns as literals (route
+   * to AC, skip metacharacter detection). Useful
+   * for deny-list patterns where "s.r.o." means
+   * the literal string, not a regex with wildcards.
+   * @default false
+   */
+  allLiteral?: boolean;
+};
+//#endregion
+//#region src/text-search.d.ts
+/**
+ * Multi-engine text search orchestrator.
+ *
+ * Routes patterns to the optimal engine
+ * configuration:
+ * - Large alternation patterns get their own
+ *   RegexSet instance (prevents DFA state explosion)
+ * - Normal patterns share a single RegexSet
+ *   (single-pass multi-pattern DFA)
+ *
+ * Merges results from all engines into a unified
+ * non-overlapping Match[] sorted by position.
+ */
+declare class TextSearch {
+  private engines;
+  private patternCount;
+  private overlapAll;
+  /**
+   * True when there's exactly one engine and all
+   * patterns map to identity indices (0→0, 1→1, ...).
+   * Enables zero-overhead findIter: return raw engine
+   * output without remapping or object allocation.
+   */
+  private zeroOverhead;
+  constructor(patterns: PatternEntry[], options?: TextSearchOptions);
+  /** Number of patterns. */
+  get length(): number;
+  /** Returns true if any pattern matches. */
+  isMatch(haystack: string): boolean;
+  /**
+   * Find matches in text.
+   *
+   * With `overlapStrategy: "longest"` (default):
+   * returns non-overlapping matches, longest wins.
+   *
+   * With `overlapStrategy: "all"`: returns all
+   * matches including overlaps, sorted by position.
+   */
+  findIter(haystack: string): Match[];
+  /** Which pattern indices matched (not where). */
+  whichMatch(haystack: string): number[];
+  /**
+   * Replace all non-overlapping matches.
+   * replacements[i] replaces pattern i.
+   */
+  replaceAll(haystack: string, replacements: string[]): string;
+}
+//#endregion
+export { type Match, type PatternEntry, TextSearch, type TextSearchOptions };
+//# sourceMappingURL=index-BIQ38WSF.d.ts.map

package/dist/index.js

@@ -1,464 +1,414 @@
-// src/text-search.ts
 import { AhoCorasick } from "@stll/aho-corasick";
 import { FuzzySearch } from "@stll/fuzzy-search";
 import { RegexSet } from "@stll/regex-set";
-
-// src/classify.ts
+//#region src/classify.ts
+/**
+* Check if a string is a pure literal (no regex
+* metacharacters). Pure literals are routed to
+* Aho-Corasick instead of the regex DFA.
+*/
 function isLiteralPattern(pattern) {
-  for (let i = 0; i < pattern.length; i++) {
-    const ch = pattern[i];
-    if (ch === "\\" || ch === "." || ch === "^" || ch === "$" || ch === "*" || ch === "+" || ch === "?" || ch === "{" || ch === "}" || ch === "(" || ch === ")" || ch === "[" || ch === "]" || ch === "|") {
-      return false;
-    }
-  }
-  return pattern.length > 0;
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "\\" || ch === "." || ch === "^" || ch === "$" || ch === "*" || ch === "+" || ch === "?" || ch === "{" || ch === "}" || ch === "(" || ch === ")" || ch === "[" || ch === "]" || ch === "|") return false;
+	}
+	return pattern.length > 0;
 }
+/**
+* Count the maximum alternation branches at any
+* depth in a regex string. Used to detect patterns
+* with large alternations (even nested inside
+* groups) that should be isolated into their own
+* RegexSet to prevent DFA state explosion.
+*
+* "a|b|c" → 3
+* "(a|b)|c" → 2 (max of top=2, depth1=2)
+* "(?:Ing\\.|Mgr\\.|Dr\\.)" → 3 (depth 1)
+*/
 function countAlternations(pattern) {
-  let depth = 0;
-  let inClass = false;
-  let i = 0;
-  let max = 1;
-  let currentCount = 1;
-  const stack = [];
-  while (i < pattern.length) {
-    const ch = pattern[i];
-    if (ch === "\\" && i + 1 < pattern.length) {
-      i += 2;
-      continue;
-    }
-    if (ch === "[") inClass = true;
-    if (ch === "]") inClass = false;
-    if (!inClass) {
-      if (ch === "(") {
-        stack.push(currentCount);
-        currentCount = 1;
-        depth++;
-      }
-      if (ch === ")") {
-        if (currentCount > max) max = currentCount;
-        currentCount = stack.pop() ?? 1;
-        depth--;
-      }
-      if (ch === "|") {
-        currentCount++;
-      }
-    }
-    i++;
-  }
-  if (currentCount > max) max = currentCount;
-  return max;
+	let depth = 0;
+	let inClass = false;
+	let i = 0;
+	let max = 1;
+	let currentCount = 1;
+	const stack = [];
+	while (i < pattern.length) {
+		const ch = pattern[i];
+		if (ch === "\\" && i + 1 < pattern.length) {
+			i += 2;
+			continue;
+		}
+		if (ch === "[") inClass = true;
+		if (ch === "]") inClass = false;
+		if (!inClass) {
+			if (ch === "(") {
+				stack.push(currentCount);
+				currentCount = 1;
+				depth++;
+			}
+			if (ch === ")") {
+				if (currentCount > max) max = currentCount;
+				currentCount = stack.pop() ?? 1;
+				depth--;
+			}
+			if (ch === "|") currentCount++;
+		}
+		i++;
+	}
+	if (currentCount > max) max = currentCount;
+	return max;
 }
+/**
+* Classify and normalize pattern entries.
+*/
 function classifyPatterns(entries, allLiteral = false) {
-  return entries.map((entry, i) => {
-    if (typeof entry === "string") {
-      return {
-        originalIndex: i,
-        pattern: entry,
-        alternationCount: allLiteral ? 0 : countAlternations(entry),
-        isLiteral: allLiteral || isLiteralPattern(entry)
-      };
-    }
-    if (entry instanceof RegExp) {
-      return {
-        originalIndex: i,
-        pattern: entry,
-        alternationCount: countAlternations(
-          entry.source
-        ),
-        isLiteral: false
-        // RegExp is never literal
-      };
-    }
-    if ("distance" in entry) {
-      const result2 = {
-        originalIndex: i,
-        pattern: entry.pattern,
-        alternationCount: 0,
-        isLiteral: false,
-        fuzzyDistance: entry.distance
-      };
-      if (entry.name !== void 0) result2.name = entry.name;
-      return result2;
-    }
-    if ("literal" in entry && entry.literal) {
-      const hasPerPatternOpts = "caseInsensitive" in entry || "wholeWords" in entry;
-      const result2 = {
-        originalIndex: i,
-        pattern: entry.pattern,
-        alternationCount: 0,
-        isLiteral: true
-      };
-      if (entry.name !== void 0) result2.name = entry.name;
-      if (hasPerPatternOpts) {
-        const opts = {};
-        if (entry.caseInsensitive !== void 0)
-          opts.caseInsensitive = entry.caseInsensitive;
-        if (entry.wholeWords !== void 0)
-          opts.wholeWords = entry.wholeWords;
-        result2.acOptions = opts;
-      }
-      return result2;
-    }
-    const pat = entry.pattern;
-    const source = pat instanceof RegExp ? pat.source : pat;
-    const result = {
-      originalIndex: i,
-      pattern: pat,
-      alternationCount: allLiteral ? 0 : countAlternations(source),
-      isLiteral: typeof pat === "string" && (allLiteral || isLiteralPattern(pat))
-    };
-    if (entry.name !== void 0) result.name = entry.name;
-    return result;
-  });
+	return entries.map((entry, i) => {
+		if (typeof entry === "string") return {
+			originalIndex: i,
+			pattern: entry,
+			alternationCount: allLiteral ? 0 : countAlternations(entry),
+			isLiteral: allLiteral || isLiteralPattern(entry)
+		};
+		if (entry instanceof RegExp) return {
+			originalIndex: i,
+			pattern: entry,
+			alternationCount: countAlternations(entry.source),
+			isLiteral: false
+		};
+		if ("distance" in entry) {
+			const result = {
+				originalIndex: i,
+				pattern: entry.pattern,
+				alternationCount: 0,
+				isLiteral: false,
+				fuzzyDistance: entry.distance
+			};
+			if (entry.name !== void 0) result.name = entry.name;
+			return result;
+		}
+		if ("literal" in entry && entry.literal) {
+			const hasPerPatternOpts = "caseInsensitive" in entry || "wholeWords" in entry;
+			const result = {
+				originalIndex: i,
+				pattern: entry.pattern,
+				alternationCount: 0,
+				isLiteral: true
+			};
+			if (entry.name !== void 0) result.name = entry.name;
+			if (hasPerPatternOpts) {
+				const opts = {};
+				if (entry.caseInsensitive !== void 0) opts.caseInsensitive = entry.caseInsensitive;
+				if (entry.wholeWords !== void 0) opts.wholeWords = entry.wholeWords;
+				result.acOptions = opts;
+			}
+			return result;
+		}
+		const pat = entry.pattern;
+		const source = pat instanceof RegExp ? pat.source : pat;
+		const result = {
+			originalIndex: i,
+			pattern: pat,
+			alternationCount: allLiteral ? 0 : countAlternations(source),
+			isLiteral: typeof pat === "string" && (allLiteral || isLiteralPattern(pat))
+		};
+		if (entry.name !== void 0) result.name = entry.name;
+		return result;
+	});
 }
-
-// src/merge.ts
+//#endregion
+//#region src/merge.ts
+/**
+* Merge matches from multiple engines, sort by
+* position, and select non-overlapping (longest
+* first at ties). Same algorithm as regex-set's
+* internal select_non_overlapping.
+*/
 function mergeAndSelect(matches) {
-  if (matches.length <= 1) return matches;
-  matches.sort((a, b) => {
-    if (a.start !== b.start) {
-      return a.start - b.start;
-    }
-    return b.end - b.start - (a.end - a.start);
-  });
-  const selected = [];
-  let lastEnd = 0;
-  for (const m of matches) {
-    if (m.start >= lastEnd) {
-      selected.push(m);
-      lastEnd = m.end;
-    }
-  }
-  return selected;
+	if (matches.length <= 1) return matches;
+	matches.sort((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		return b.end - b.start - (a.end - a.start);
+	});
+	const selected = [];
+	let lastEnd = 0;
+	for (const m of matches) if (m.start >= lastEnd) {
+		selected.push(m);
+		lastEnd = m.end;
+	}
+	return selected;
 }
-
-// src/text-search.ts
+//#endregion
+//#region src/text-search.ts
+/**
+* Multi-engine text search orchestrator.
+*
+* Routes patterns to the optimal engine
+* configuration:
+* - Large alternation patterns get their own
+*   RegexSet instance (prevents DFA state explosion)
+* - Normal patterns share a single RegexSet
+*   (single-pass multi-pattern DFA)
+*
+* Merges results from all engines into a unified
+* non-overlapping Match[] sorted by position.
+*/
 var TextSearch = class {
-  engines = [];
-  patternCount;
-  overlapAll;
-  /**
-   * True when there's exactly one engine and all
-   * patterns map to identity indices (0→0, 1→1, ...).
-   * Enables zero-overhead findIter: return raw engine
-   * output without remapping or object allocation.
-   */
-  zeroOverhead = false;
-  constructor(patterns, options) {
-    this.patternCount = patterns.length;
-    this.overlapAll = options?.overlapStrategy === "all";
-    const maxAlt = options?.maxAlternations ?? 50;
-    const classified = classifyPatterns(
-      patterns,
-      options?.allLiteral ?? false
-    );
-    const fuzzy = [];
-    const literals = [];
-    const shared = [];
-    const isolated = [];
-    for (const cp of classified) {
-      if (cp.fuzzyDistance !== void 0) {
-        fuzzy.push(cp);
-      } else if (cp.isLiteral) {
-        literals.push(cp);
-      } else if (cp.alternationCount > maxAlt) {
-        isolated.push(cp);
-      } else {
-        shared.push(cp);
-      }
-    }
-    const rsOptions = {
-      unicodeBoundaries: options?.unicodeBoundaries ?? true,
-      wholeWords: options?.wholeWords ?? false,
-      caseInsensitive: options?.caseInsensitive ?? false
-    };
-    if (fuzzy.length > 0) {
-      const fuzzyOpts = {
-        unicodeBoundaries: rsOptions.unicodeBoundaries,
-        wholeWords: rsOptions.wholeWords
-      };
-      if (options?.fuzzyMetric !== void 0)
-        fuzzyOpts.metric = options.fuzzyMetric;
-      if (options?.normalizeDiacritics !== void 0)
-        fuzzyOpts.normalizeDiacritics = options.normalizeDiacritics;
-      if (options?.caseInsensitive !== void 0)
-        fuzzyOpts.caseInsensitive = options.caseInsensitive;
-      this.engines.push(
-        buildFuzzyEngine(fuzzy, fuzzyOpts)
-      );
-    }
-    if (literals.length > 0) {
-      const groups = /* @__PURE__ */ new Map();
-      for (const cp of literals) {
-        const ci = cp.acOptions?.caseInsensitive ?? rsOptions.caseInsensitive;
-        const ww = cp.acOptions?.wholeWords ?? rsOptions.wholeWords;
-        const key = `${ci ? 1 : 0}:${ww ? 1 : 0}`;
-        const group = groups.get(key);
-        if (group) {
-          group.push(cp);
-        } else {
-          groups.set(key, [cp]);
-        }
-      }
-      for (const [key, group] of groups) {
-        const [ci, ww] = key.split(":");
-        this.engines.push(
-          buildAcEngine(group, {
-            ...rsOptions,
-            caseInsensitive: ci === "1",
-            wholeWords: ww === "1"
-          })
-        );
-      }
-    }
-    if (shared.length > 1) {
-      const combined = buildRegexEngine(
-        shared,
-        rsOptions
-      );
-      const probe = "Hello World 123 test@example.com 2025-01-01 +420 123 456 789 Ing. Jan Nov\xE1k, s.r.o. Praha 1 ".repeat(10);
-      const t0 = performance.now();
-      combined.rs.findIter(probe);
-      const combinedMs = performance.now() - t0;
-      let individualMs = 0;
-      const individualEngines = [];
-      for (const cp of shared) {
-        const eng = buildRegexEngine(
-          [cp],
-          rsOptions
-        );
-        const t1 = performance.now();
-        eng.rs.findIter(probe);
-        individualMs += performance.now() - t1;
-        individualEngines.push(eng);
-      }
-      if (combinedMs > individualMs * 1.5) {
-        for (const eng of individualEngines) {
-          this.engines.push(eng);
-        }
-      } else {
-        this.engines.push(combined);
-      }
-    } else if (shared.length === 1) {
-      this.engines.push(
-        buildRegexEngine(shared, rsOptions)
-      );
-    }
-    for (const cp of isolated) {
-      this.engines.push(
-        buildRegexEngine([cp], rsOptions)
-      );
-    }
-    if (this.engines.length === 1) {
-      const engine = this.engines[0];
-      const hasNames = engine.nameMap.some(
-        (n) => n !== void 0
-      );
-      if (!hasNames) {
-        this.zeroOverhead = true;
-      }
-    }
-  }
-  /** Number of patterns. */
-  get length() {
-    return this.patternCount;
-  }
-  /** Returns true if any pattern matches. */
-  isMatch(haystack) {
-    for (const engine of this.engines) {
-      if (engineIsMatch(engine, haystack)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Find matches in text.
-   *
-   * With `overlapStrategy: "longest"` (default):
-   * returns non-overlapping matches, longest wins.
-   *
-   * With `overlapStrategy: "all"`: returns all
-   * matches including overlaps, sorted by position.
-   */
-  findIter(haystack) {
-    if (this.zeroOverhead) {
-      return engineFindIter(
-        this.engines[0],
-        haystack
-      );
-    }
-    if (this.engines.length === 1) {
-      return remapMatches(
-        engineFindIter(this.engines[0], haystack),
-        this.engines[0]
-      );
-    }
-    const all = [];
-    for (const engine of this.engines) {
-      const matches = engineFindIter(
-        engine,
-        haystack
-      );
-      for (const m of remapMatches(matches, engine)) {
-        all.push(m);
-      }
-    }
-    if (this.overlapAll) {
-      return all.sort(
-        (a, b) => a.start - b.start
-      );
-    }
-    return mergeAndSelect(all);
-  }
-  /** Which pattern indices matched (not where). */
-  whichMatch(haystack) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const engine of this.engines) {
-      const matches = engineFindIter(
-        engine,
-        haystack
-      );
-      for (const m of matches) {
-        seen.add(engine.indexMap[m.pattern]);
-      }
-    }
-    return [...seen];
-  }
-  /**
-   * Replace all non-overlapping matches.
-   * replacements[i] replaces pattern i.
-   */
-  replaceAll(haystack, replacements) {
-    if (replacements.length !== this.patternCount) {
-      throw new Error(
-        `Expected ${this.patternCount} replacements, got ${replacements.length}`
-      );
-    }
-    const all = [];
-    for (const engine of this.engines) {
-      const matches2 = engineFindIter(
-        engine,
-        haystack
-      );
-      for (const m of remapMatches(matches2, engine)) {
-        all.push(m);
-      }
-    }
-    const matches = mergeAndSelect(all);
-    let result = "";
-    let last = 0;
-    for (const m of matches) {
-      result += haystack.slice(last, m.start);
-      result += replacements[m.pattern];
-      last = m.end;
-    }
-    result += haystack.slice(last);
-    return result;
-  }
+	engines = [];
+	patternCount;
+	overlapAll;
+	/**
+	* True when there's exactly one engine and all
+	* patterns map to identity indices (0→0, 1→1, ...).
+	* Enables zero-overhead findIter: return raw engine
+	* output without remapping or object allocation.
+	*/
+	zeroOverhead = false;
+	constructor(patterns, options) {
+		this.patternCount = patterns.length;
+		this.overlapAll = options?.overlapStrategy === "all";
+		const maxAlt = options?.maxAlternations ?? 50;
+		const classified = classifyPatterns(patterns, options?.allLiteral ?? false);
+		const fuzzy = [];
+		const literals = [];
+		const shared = [];
+		const isolated = [];
+		for (const cp of classified) if (cp.fuzzyDistance !== void 0) fuzzy.push(cp);
+		else if (cp.isLiteral) literals.push(cp);
+		else if (cp.alternationCount > maxAlt) isolated.push(cp);
+		else shared.push(cp);
+		const rsOptions = {
+			unicodeBoundaries: options?.unicodeBoundaries ?? true,
+			wholeWords: options?.wholeWords ?? false,
+			caseInsensitive: options?.caseInsensitive ?? false
+		};
+		if (fuzzy.length > 0) {
+			const fuzzyOpts = {
+				unicodeBoundaries: rsOptions.unicodeBoundaries,
+				wholeWords: rsOptions.wholeWords
+			};
+			if (options?.fuzzyMetric !== void 0) fuzzyOpts.metric = options.fuzzyMetric;
+			if (options?.normalizeDiacritics !== void 0) fuzzyOpts.normalizeDiacritics = options.normalizeDiacritics;
+			if (options?.caseInsensitive !== void 0) fuzzyOpts.caseInsensitive = options.caseInsensitive;
+			this.engines.push(buildFuzzyEngine(fuzzy, fuzzyOpts));
+		}
+		if (literals.length > 0) {
+			const groups = /* @__PURE__ */ new Map();
+			for (const cp of literals) {
+				const ci = cp.acOptions?.caseInsensitive ?? rsOptions.caseInsensitive;
+				const ww = cp.acOptions?.wholeWords ?? rsOptions.wholeWords;
+				const key = `${ci ? 1 : 0}:${ww ? 1 : 0}`;
+				const group = groups.get(key);
+				if (group) group.push(cp);
+				else groups.set(key, [cp]);
+			}
+			for (const [key, group] of groups) {
+				const [ci, ww] = key.split(":");
+				this.engines.push(buildAcEngine(group, {
+					...rsOptions,
+					caseInsensitive: ci === "1",
+					wholeWords: ww === "1"
+				}));
+			}
+		}
+		if (shared.length > 1) {
+			const combined = buildRegexEngine(shared, rsOptions);
+			const probe = "Hello World 123 test@example.com 2025-01-01 +420 123 456 789 Ing. Jan Novák, s.r.o. Praha 1 ".repeat(10);
+			const t0 = performance.now();
+			combined.rs.findIter(probe);
+			const combinedMs = performance.now() - t0;
+			let individualMs = 0;
+			const individualEngines = [];
+			for (const cp of shared) {
+				const eng = buildRegexEngine([cp], rsOptions);
+				const t1 = performance.now();
+				eng.rs.findIter(probe);
+				individualMs += performance.now() - t1;
+				individualEngines.push(eng);
+			}
+			if (combinedMs > individualMs * 1.5) for (const eng of individualEngines) this.engines.push(eng);
+			else this.engines.push(combined);
+		} else if (shared.length === 1) this.engines.push(buildRegexEngine(shared, rsOptions));
+		for (const cp of isolated) this.engines.push(buildRegexEngine([cp], rsOptions));
+		if (this.engines.length === 1) {
+			if (!this.engines[0].nameMap.some((n) => n !== void 0)) this.zeroOverhead = true;
+		}
+	}
+	/** Number of patterns. */
+	get length() {
+		return this.patternCount;
+	}
+	/** Returns true if any pattern matches. */
+	isMatch(haystack) {
+		for (const engine of this.engines) if (engineIsMatch(engine, haystack)) return true;
+		return false;
+	}
+	/**
+	* Find matches in text.
+	*
+	* With `overlapStrategy: "longest"` (default):
+	* returns non-overlapping matches, longest wins.
+	*
+	* With `overlapStrategy: "all"`: returns all
+	* matches including overlaps, sorted by position.
+	*/
+	findIter(haystack) {
+		if (this.zeroOverhead) return engineFindIter(this.engines[0], haystack);
+		if (this.engines.length === 1) return remapMatches(engineFindIter(this.engines[0], haystack), this.engines[0]);
+		const all = [];
+		for (const engine of this.engines) {
+			const matches = engineFindIter(engine, haystack);
+			for (const m of remapMatches(matches, engine)) all.push(m);
+		}
+		if (this.overlapAll) return all.sort((a, b) => a.start - b.start);
+		return mergeAndSelect(all);
+	}
+	/** Which pattern indices matched (not where). */
+	whichMatch(haystack) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const engine of this.engines) {
+			const matches = engineFindIter(engine, haystack);
+			for (const m of matches) seen.add(engine.indexMap[m.pattern]);
+		}
+		return [...seen];
+	}
+	/**
+	* Replace all non-overlapping matches.
+	* replacements[i] replaces pattern i.
+	*/
+	replaceAll(haystack, replacements) {
+		if (replacements.length !== this.patternCount) throw new Error(`Expected ${this.patternCount} replacements, got ${replacements.length}`);
+		const all = [];
+		for (const engine of this.engines) {
+			const matches = engineFindIter(engine, haystack);
+			for (const m of remapMatches(matches, engine)) all.push(m);
+		}
+		const matches = mergeAndSelect(all);
+		let result = "";
+		let last = 0;
+		for (const m of matches) {
+			result += haystack.slice(last, m.start);
+			result += replacements[m.pattern];
+			last = m.end;
+		}
+		result += haystack.slice(last);
+		return result;
+	}
 };
+/**
+* Build a RegexSet engine from classified patterns.
+*/
 function buildRegexEngine(patterns, options) {
-  const rsPatterns = [];
-  const indexMap = [];
-  const nameMap = [];
-  for (const cp of patterns) {
-    if (cp.name !== void 0) {
-      rsPatterns.push({
-        pattern: cp.pattern,
-        name: cp.name
-      });
-    } else {
-      rsPatterns.push(cp.pattern);
-    }
-    indexMap.push(cp.originalIndex);
-    nameMap.push(cp.name);
-  }
-  const rs = new RegexSet(rsPatterns, options);
-  return { type: "regex", rs, indexMap, nameMap };
+	const rsPatterns = [];
+	const indexMap = [];
+	const nameMap = [];
+	for (const cp of patterns) {
+		if (cp.name !== void 0) rsPatterns.push({
+			pattern: cp.pattern,
+			name: cp.name
+		});
+		else rsPatterns.push(cp.pattern);
+		indexMap.push(cp.originalIndex);
+		nameMap.push(cp.name);
+	}
+	return {
+		type: "regex",
+		rs: new RegexSet(rsPatterns, options),
+		indexMap,
+		nameMap
+	};
 }
+/**
+* Build an Aho-Corasick engine from literal patterns.
+*/
 function buildAcEngine(patterns, options) {
-  const literals = [];
-  const indexMap = [];
-  const nameMap = [];
-  for (const cp of patterns) {
-    literals.push(cp.pattern);
-    indexMap.push(cp.originalIndex);
-    nameMap.push(cp.name);
-  }
-  const ac = new AhoCorasick(literals, {
-    wholeWords: options.wholeWords,
-    unicodeBoundaries: options.unicodeBoundaries,
-    caseInsensitive: options.caseInsensitive
-  });
-  return { type: "ac", ac, indexMap, nameMap };
+	const literals = [];
+	const indexMap = [];
+	const nameMap = [];
+	for (const cp of patterns) {
+		literals.push(cp.pattern);
+		indexMap.push(cp.originalIndex);
+		nameMap.push(cp.name);
+	}
+	return {
+		type: "ac",
+		ac: new AhoCorasick(literals, {
+			wholeWords: options.wholeWords,
+			unicodeBoundaries: options.unicodeBoundaries,
+			caseInsensitive: options.caseInsensitive
+		}),
+		indexMap,
+		nameMap
+	};
 }
+/**
+* Build a FuzzySearch engine from fuzzy patterns.
+*/
 function buildFuzzyEngine(patterns, options) {
-  const fsPatterns = [];
-  const indexMap = [];
-  const nameMap = [];
-  for (const cp of patterns) {
-    const entry = {
-      pattern: cp.pattern
-    };
-    if (cp.fuzzyDistance !== void 0)
-      entry.distance = cp.fuzzyDistance;
-    if (cp.name !== void 0) entry.name = cp.name;
-    fsPatterns.push(entry);
-    indexMap.push(cp.originalIndex);
-    nameMap.push(cp.name);
-  }
-  const fsOptions = {
-    unicodeBoundaries: options.unicodeBoundaries,
-    wholeWords: options.wholeWords
-  };
-  if (options.metric !== void 0)
-    fsOptions.metric = options.metric;
-  if (options.normalizeDiacritics !== void 0)
-    fsOptions.normalizeDiacritics = options.normalizeDiacritics;
-  if (options.caseInsensitive !== void 0)
-    fsOptions.caseInsensitive = options.caseInsensitive;
-  const fs = new FuzzySearch(fsPatterns, fsOptions);
-  return { type: "fuzzy", fs, indexMap, nameMap };
+	const fsPatterns = [];
+	const indexMap = [];
+	const nameMap = [];
+	for (const cp of patterns) {
+		const entry = { pattern: cp.pattern };
+		if (cp.fuzzyDistance !== void 0) entry.distance = cp.fuzzyDistance;
+		if (cp.name !== void 0) entry.name = cp.name;
+		fsPatterns.push(entry);
+		indexMap.push(cp.originalIndex);
+		nameMap.push(cp.name);
+	}
+	const fsOptions = {
+		unicodeBoundaries: options.unicodeBoundaries,
+		wholeWords: options.wholeWords
+	};
+	if (options.metric !== void 0) fsOptions.metric = options.metric;
+	if (options.normalizeDiacritics !== void 0) fsOptions.normalizeDiacritics = options.normalizeDiacritics;
+	if (options.caseInsensitive !== void 0) fsOptions.caseInsensitive = options.caseInsensitive;
+	return {
+		type: "fuzzy",
+		fs: new FuzzySearch(fsPatterns, fsOptions),
+		indexMap,
+		nameMap
+	};
 }
+/**
+* Dispatch isMatch to the correct engine.
+*/
 function engineIsMatch(engine, haystack) {
-  switch (engine.type) {
-    case "ac":
-      return engine.ac.isMatch(haystack);
-    case "fuzzy":
-      return engine.fs.isMatch(haystack);
-    case "regex":
-      return engine.rs.isMatch(haystack);
-  }
+	switch (engine.type) {
+		case "ac": return engine.ac.isMatch(haystack);
+		case "fuzzy": return engine.fs.isMatch(haystack);
+		case "regex": return engine.rs.isMatch(haystack);
+	}
 }
+/**
+* Dispatch findIter to the correct engine.
+*/
 function engineFindIter(engine, haystack) {
-  switch (engine.type) {
-    case "ac":
-      return engine.ac.findIter(haystack);
-    case "fuzzy":
-      return engine.fs.findIter(haystack);
-    case "regex":
-      return engine.rs.findIter(haystack);
-  }
+	switch (engine.type) {
+		case "ac": return engine.ac.findIter(haystack);
+		case "fuzzy": return engine.fs.findIter(haystack);
+		case "regex": return engine.rs.findIter(haystack);
+	}
 }
+/**
+* Remap engine-local match indices to original
+* input indices and add names.
+*/
 function remapMatches(matches, engine) {
-  return matches.map((m) => {
-    const originalIdx = engine.indexMap[m.pattern];
-    const name = engine.nameMap[m.pattern];
-    const result = {
-      pattern: originalIdx,
-      start: m.start,
-      end: m.end,
-      text: m.text
-    };
-    if (name !== void 0) {
-      result.name = name;
-    }
-    if ("distance" in m && m.distance !== void 0) {
-      result.distance = m.distance;
-    }
-    return result;
-  });
+	return matches.map((m) => {
+		const originalIdx = engine.indexMap[m.pattern];
+		const name = engine.nameMap[m.pattern];
+		const result = {
+			pattern: originalIdx,
+			start: m.start,
+			end: m.end,
+			text: m.text
+		};
+		if (name !== void 0) result.name = name;
+		if ("distance" in m && m.distance !== void 0) result.distance = m.distance;
+		return result;
+	});
 }
-export {
-  TextSearch
-};
+//#endregion
+export { TextSearch };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/classify.ts","../src/merge.ts","../src/text-search.ts"],"sourcesContent":["import type { PatternEntry } from \"./types\";\n\n/**\n * Normalized pattern with metadata for routing.\n */\nexport type ClassifiedPattern = {\n  /** Original index in the input array. */\n  originalIndex: number;\n  /** The regex-compatible pattern string. */\n  pattern: string | RegExp;\n  /** Optional name. */\n  name?: string;\n  /**\n   * Number of top-level alternation branches.\n   * Used to detect large alternations that should\n   * be isolated into their own RegexSet instance.\n   */\n  alternationCount: number;\n  /**\n   * True if the pattern is a pure literal string\n   * (no regex metacharacters). These can be routed\n   * to Aho-Corasick for SIMD-accelerated matching.\n   */\n  isLiteral: boolean;\n  /**\n   * Fuzzy distance if this is a fuzzy pattern.\n   * Routes to @stll/fuzzy-search.\n   */\n  fuzzyDistance?: number | \"auto\";\n  /**\n   * Per-pattern AC options. When set, this literal\n   * is grouped with others that have the same\n   * options into a separate AC engine instance.\n   */\n  acOptions?: {\n    caseInsensitive?: boolean;\n    wholeWords?: boolean;\n  };\n};\n\n/**\n * Check if a string is a pure literal (no regex\n * metacharacters). Pure literals are routed to\n * Aho-Corasick instead of the regex DFA.\n */\nexport function isLiteralPattern(\n  pattern: string,\n): boolean {\n  // All standard regex metacharacters cause a\n  // pattern to be classified as regex (→ RegexSet).\n  // To force literal AC routing for patterns with\n  // dots/parens (e.g., \"s.r.o.\", \"č.p.\"), use the\n  // explicit { literal: true } PatternEntry flag.\n  for (let i = 0; i < pattern.length; i++) {\n    const ch = pattern[i]!;\n    if (\n      ch === \"\\\\\" ||\n      ch === \".\" ||\n      ch === \"^\" ||\n      ch === \"$\" ||\n      ch === \"*\" ||\n      ch === \"+\" ||\n      ch === \"?\" ||\n      ch === \"{\" ||\n      ch === \"}\" ||\n      ch === \"(\" ||\n      ch === \")\" ||\n      ch === \"[\" ||\n      ch === \"]\" ||\n      ch === \"|\"\n    ) {\n      return false;\n    }\n  }\n  return pattern.length > 0;\n}\n\n/**\n * Count the maximum alternation branches at any\n * depth in a regex string. Used to detect patterns\n * with large alternations (even nested inside\n * groups) that should be isolated into their own\n * RegexSet to prevent DFA state explosion.\n *\n * \"a|b|c\" → 3\n * \"(a|b)|c\" → 2 (max of top=2, depth1=2)\n * \"(?:Ing\\\\.|Mgr\\\\.|Dr\\\\.)\" → 3 (depth 1)\n */\nexport function countAlternations(\n  pattern: string,\n): number {\n  let depth = 0;\n  let inClass = false;\n  let i = 0;\n\n  // Track max alternation count seen at any depth.\n  // Each time we enter a group, start a fresh count.\n  // When we leave, update the global max.\n  let max = 1;\n  let currentCount = 1; // count for current group\n  const stack: number[] = []; // saved counts\n\n  while (i < pattern.length) {\n    const ch = pattern[i];\n\n    if (ch === \"\\\\\" && i + 1 < pattern.length) {\n      i += 2;\n      continue;\n    }\n\n    if (ch === \"[\") inClass = true;\n    if (ch === \"]\") inClass = false;\n\n    if (!inClass) {\n      if (ch === \"(\") {\n        stack.push(currentCount);\n        currentCount = 1;\n        depth++;\n      }\n      if (ch === \")\") {\n        if (currentCount > max) max = currentCount;\n        currentCount = stack.pop() ?? 1;\n        depth--;\n      }\n      if (ch === \"|\") {\n        currentCount++;\n      }\n    }\n\n    i++;\n  }\n  // Check top-level count too\n  if (currentCount > max) max = currentCount;\n  return max;\n}\n\n/**\n * Classify and normalize pattern entries.\n */\nexport function classifyPatterns(\n  entries: PatternEntry[],\n  allLiteral = false,\n): ClassifiedPattern[] {\n  return entries.map((entry, i) => {\n    if (typeof entry === \"string\") {\n      return {\n        originalIndex: i,\n        pattern: entry,\n        alternationCount: allLiteral\n          ? 0\n          : countAlternations(entry),\n        isLiteral: allLiteral ||\n          isLiteralPattern(entry),\n      };\n    }\n\n    if (entry instanceof RegExp) {\n      return {\n        originalIndex: i,\n        pattern: entry,\n        alternationCount: countAlternations(\n          entry.source,\n        ),\n        isLiteral: false, // RegExp is never literal\n      };\n    }\n\n    // Fuzzy pattern: has `distance` field\n    if (\"distance\" in entry) {\n      const result: ClassifiedPattern = {\n        originalIndex: i,\n        pattern: entry.pattern,\n        alternationCount: 0,\n        isLiteral: false,\n        fuzzyDistance: entry.distance,\n      };\n      if (entry.name !== undefined) result.name = entry.name;\n      return result;\n    }\n\n    // Explicit literal: skip metachar detection\n    if (\"literal\" in entry && entry.literal) {\n      const hasPerPatternOpts =\n        \"caseInsensitive\" in entry ||\n        \"wholeWords\" in entry;\n      const result: ClassifiedPattern = {\n        originalIndex: i,\n        pattern: entry.pattern,\n        alternationCount: 0,\n        isLiteral: true,\n      };\n      if (entry.name !== undefined) result.name = entry.name;\n      if (hasPerPatternOpts) {\n        const opts: NonNullable<\n          ClassifiedPattern[\"acOptions\"]\n        > = {};\n        if (entry.caseInsensitive !== undefined)\n          opts.caseInsensitive = entry.caseInsensitive;\n        if (entry.wholeWords !== undefined)\n          opts.wholeWords = entry.wholeWords;\n        result.acOptions = opts;\n      }\n      return result;\n    }\n\n    const pat = entry.pattern;\n    const source =\n      pat instanceof RegExp ? pat.source : pat;\n\n    const result: ClassifiedPattern = {\n      originalIndex: i,\n      pattern: pat,\n      alternationCount: allLiteral\n        ? 0\n        : countAlternations(source),\n      isLiteral:\n        typeof pat === \"string\" &&\n        (allLiteral || isLiteralPattern(pat)),\n    };\n    if (entry.name !== undefined) result.name = entry.name;\n    return result;\n  });\n}\n","import type { Match } from \"./types\";\n\n/**\n * Merge matches from multiple engines, sort by\n * position, and select non-overlapping (longest\n * first at ties). Same algorithm as regex-set's\n * internal select_non_overlapping.\n */\nexport function mergeAndSelect(\n  matches: Match[],\n): Match[] {\n  if (matches.length <= 1) return matches;\n\n  // Sort: start ascending, longest first at ties\n  matches.sort((a, b) => {\n    if (a.start !== b.start) {\n      return a.start - b.start;\n    }\n    return b.end - b.start - (a.end - a.start);\n  });\n\n  // Greedily select non-overlapping\n  const selected: Match[] = [];\n  let lastEnd = 0;\n\n  for (const m of matches) {\n    if (m.start >= lastEnd) {\n      selected.push(m);\n      lastEnd = m.end;\n    }\n  }\n\n  return selected;\n}\n","import { AhoCorasick } from \"@stll/aho-corasick\";\nimport { FuzzySearch } from \"@stll/fuzzy-search\";\nimport { RegexSet } from \"@stll/regex-set\";\n\nimport type { ClassifiedPattern } from \"./classify\";\nimport { classifyPatterns } from \"./classify\";\nimport { mergeAndSelect } from \"./merge\";\nimport type {\n  Match,\n  PatternEntry,\n  TextSearchOptions,\n} from \"./types\";\n\n/**\n * An engine instance with pattern index mapping.\n */\ntype RegexSlot = {\n  type: \"regex\";\n  rs: RegexSet;\n  indexMap: number[];\n  nameMap: (string | undefined)[];\n};\n\ntype AcSlot = {\n  type: \"ac\";\n  ac: AhoCorasick;\n  indexMap: number[];\n  nameMap: (string | undefined)[];\n};\n\ntype FuzzySlot = {\n  type: \"fuzzy\";\n  fs: FuzzySearch;\n  indexMap: number[];\n  nameMap: (string | undefined)[];\n};\n\ntype EngineSlot = RegexSlot | AcSlot | FuzzySlot;\n\n/**\n * Multi-engine text search orchestrator.\n *\n * Routes patterns to the optimal engine\n * configuration:\n * - Large alternation patterns get their own\n *   RegexSet instance (prevents DFA state explosion)\n * - Normal patterns share a single RegexSet\n *   (single-pass multi-pattern DFA)\n *\n * Merges results from all engines into a unified\n * non-overlapping Match[] sorted by position.\n */\nexport class TextSearch {\n  private engines: EngineSlot[] = [];\n  private patternCount: number;\n  private overlapAll: boolean;\n  /**\n   * True when there's exactly one engine and all\n   * patterns map to identity indices (0→0, 1→1, ...).\n   * Enables zero-overhead findIter: return raw engine\n   * output without remapping or object allocation.\n   */\n  private zeroOverhead: boolean = false;\n\n  constructor(\n    patterns: PatternEntry[],\n    options?: TextSearchOptions,\n  ) {\n    this.patternCount = patterns.length;\n    this.overlapAll =\n      options?.overlapStrategy === \"all\";\n    const maxAlt = options?.maxAlternations ?? 50;\n    const classified = classifyPatterns(\n      patterns,\n      options?.allLiteral ?? false,\n    );\n\n    // Four buckets:\n    // 1. Fuzzy patterns → FuzzySearch (Levenshtein)\n    // 2. Pure literals → Aho-Corasick (SIMD)\n    // 3. Normal regex → shared RegexSet (DFA)\n    // 4. Large alternations → isolated RegexSet\n    const fuzzy: ClassifiedPattern[] = [];\n    const literals: ClassifiedPattern[] = [];\n    const shared: ClassifiedPattern[] = [];\n    const isolated: ClassifiedPattern[] = [];\n\n    for (const cp of classified) {\n      if (cp.fuzzyDistance !== undefined) {\n        fuzzy.push(cp);\n      } else if (cp.isLiteral) {\n        literals.push(cp);\n      } else if (cp.alternationCount > maxAlt) {\n        isolated.push(cp);\n      } else {\n        shared.push(cp);\n      }\n    }\n\n    const rsOptions = {\n      unicodeBoundaries:\n        options?.unicodeBoundaries ?? true,\n      wholeWords: options?.wholeWords ?? false,\n      caseInsensitive:\n        options?.caseInsensitive ?? false,\n    };\n\n    // Build fuzzy engine\n    if (fuzzy.length > 0) {\n      const fuzzyOpts: Parameters<\n        typeof buildFuzzyEngine\n      >[1] = {\n        unicodeBoundaries:\n          rsOptions.unicodeBoundaries,\n        wholeWords: rsOptions.wholeWords,\n      };\n      if (options?.fuzzyMetric !== undefined)\n        fuzzyOpts.metric = options.fuzzyMetric;\n      if (options?.normalizeDiacritics !== undefined)\n        fuzzyOpts.normalizeDiacritics =\n          options.normalizeDiacritics;\n      if (options?.caseInsensitive !== undefined)\n        fuzzyOpts.caseInsensitive =\n          options.caseInsensitive;\n      this.engines.push(\n        buildFuzzyEngine(fuzzy, fuzzyOpts),\n      );\n    }\n\n    // Build AC engine(s) for pure literals.\n    // Group by per-pattern AC options so patterns\n    // with different caseInsensitive/wholeWords\n    // settings get separate AC instances.\n    if (literals.length > 0) {\n      const groups = new Map<\n        string,\n        ClassifiedPattern[]\n      >();\n      for (const cp of literals) {\n        const ci =\n          cp.acOptions?.caseInsensitive ??\n          rsOptions.caseInsensitive;\n        const ww =\n          cp.acOptions?.wholeWords ??\n          rsOptions.wholeWords;\n        const key = `${ci ? 1 : 0}:${ww ? 1 : 0}`;\n        const group = groups.get(key);\n        if (group) {\n          group.push(cp);\n        } else {\n          groups.set(key, [cp]);\n        }\n      }\n      for (const [key, group] of groups) {\n        const [ci, ww] = key.split(\":\");\n        this.engines.push(\n          buildAcEngine(group, {\n            ...rsOptions,\n            caseInsensitive: ci === \"1\",\n            wholeWords: ww === \"1\",\n          }),\n        );\n      }\n    }\n\n    // Adaptive regex grouping: try combining shared\n    // patterns, measure actual search time on a\n    // probe string. If combined is slower than\n    // individual, fall back to isolation.\n    if (shared.length > 1) {\n      const combined = buildRegexEngine(\n        shared,\n        rsOptions,\n      );\n      // Probe: 1KB of mixed content\n      const probe = (\n        \"Hello World 123 test@example.com \" +\n        \"2025-01-01 +420 123 456 789 \" +\n        \"Ing. Jan Novák, s.r.o. Praha 1 \"\n      ).repeat(10);\n      const t0 = performance.now();\n      combined.rs.findIter(probe);\n      const combinedMs = performance.now() - t0;\n\n      // Individual baseline (sum of isolated scans)\n      let individualMs = 0;\n      const individualEngines: RegexSlot[] = [];\n      for (const cp of shared) {\n        const eng = buildRegexEngine(\n          [cp],\n          rsOptions,\n        );\n        const t1 = performance.now();\n        eng.rs.findIter(probe);\n        individualMs += performance.now() - t1;\n        individualEngines.push(eng);\n      }\n\n      if (combinedMs > individualMs * 1.5) {\n        // Combined is >1.5x slower — isolate\n        for (const eng of individualEngines) {\n          this.engines.push(eng);\n        }\n      } else {\n        this.engines.push(combined);\n      }\n    } else if (shared.length === 1) {\n      this.engines.push(\n        buildRegexEngine(shared, rsOptions),\n      );\n    }\n\n    for (const cp of isolated) {\n      this.engines.push(\n        buildRegexEngine([cp], rsOptions),\n      );\n    }\n\n    // Zero-overhead fast path: when all patterns\n    // land in a single engine, the indexMap is\n    // identity (0→0, 1→1, ...) and no names need\n    // attaching. findIter can return raw engine\n    // output without any JS-side remapping.\n    if (this.engines.length === 1) {\n      const engine = this.engines[0]!;\n      const hasNames = engine.nameMap.some(\n        (n) => n !== undefined,\n      );\n      if (!hasNames) {\n        this.zeroOverhead = true;\n      }\n    }\n  }\n\n  /** Number of patterns. */\n  get length(): number {\n    return this.patternCount;\n  }\n\n  /** Returns true if any pattern matches. */\n  isMatch(haystack: string): boolean {\n    for (const engine of this.engines) {\n      if (engineIsMatch(engine, haystack)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Find matches in text.\n   *\n   * With `overlapStrategy: \"longest\"` (default):\n   * returns non-overlapping matches, longest wins.\n   *\n   * With `overlapStrategy: \"all\"`: returns all\n   * matches including overlaps, sorted by position.\n   */\n  findIter(haystack: string): Match[] {\n    // Fast path: single engine, identity indexMap,\n    // no names → return raw engine output directly.\n    // Zero JS overhead: no remapping, no allocation.\n    if (this.zeroOverhead) {\n      return engineFindIter(\n        this.engines[0]!,\n        haystack,\n      );\n    }\n\n    // Single engine but needs name remapping\n    if (this.engines.length === 1) {\n      return remapMatches(\n        engineFindIter(this.engines[0]!, haystack),\n        this.engines[0]!,\n      );\n    }\n\n    // Multi-engine: collect from all, remap in-place\n    const all: Match[] = [];\n    for (const engine of this.engines) {\n      const matches = engineFindIter(\n        engine,\n        haystack,\n      );\n      // In-place remapping avoids .map() allocation\n      for (const m of remapMatches(matches, engine)) {\n        all.push(m);\n      }\n    }\n\n    if (this.overlapAll) {\n      return all.sort(\n        (a, b) => a.start - b.start,\n      );\n    }\n\n    return mergeAndSelect(all);\n  }\n\n  /** Which pattern indices matched (not where). */\n  whichMatch(haystack: string): number[] {\n    const seen = new Set<number>();\n\n    for (const engine of this.engines) {\n      // AC doesn't have whichMatch — use findIter\n      const matches = engineFindIter(\n        engine,\n        haystack,\n      );\n      for (const m of matches) {\n        seen.add(engine.indexMap[m.pattern]!);\n      }\n    }\n\n    return [...seen];\n  }\n\n  /**\n   * Replace all non-overlapping matches.\n   * replacements[i] replaces pattern i.\n   */\n  replaceAll(\n    haystack: string,\n    replacements: string[],\n  ): string {\n    if (replacements.length !== this.patternCount) {\n      throw new Error(\n        `Expected ${this.patternCount} ` +\n          `replacements, got ${replacements.length}`,\n      );\n    }\n\n    // Always use non-overlapping matches for\n    // replacement, even if overlapStrategy is \"all\".\n    const all: Match[] = [];\n    for (const engine of this.engines) {\n      const matches = engineFindIter(\n        engine,\n        haystack,\n      );\n      for (const m of remapMatches(matches, engine)) {\n        all.push(m);\n      }\n    }\n    const matches = mergeAndSelect(all);\n\n    let result = \"\";\n    let last = 0;\n\n    for (const m of matches) {\n      result += haystack.slice(last, m.start);\n      result += replacements[m.pattern]!;\n      last = m.end;\n    }\n\n    result += haystack.slice(last);\n    return result;\n  }\n}\n\n/**\n * Build a RegexSet engine from classified patterns.\n */\nfunction buildRegexEngine(\n  patterns: ClassifiedPattern[],\n  options: {\n    unicodeBoundaries: boolean;\n    wholeWords: boolean;\n    caseInsensitive: boolean;\n  },\n): RegexSlot {\n  const rsPatterns: (string | RegExp | {\n    pattern: string | RegExp;\n    name?: string;\n  })[] = [];\n  const indexMap: number[] = [];\n  const nameMap: (string | undefined)[] = [];\n\n  for (const cp of patterns) {\n    if (cp.name !== undefined) {\n      rsPatterns.push({\n        pattern: cp.pattern,\n        name: cp.name,\n      });\n    } else {\n      rsPatterns.push(cp.pattern);\n    }\n    indexMap.push(cp.originalIndex);\n    nameMap.push(cp.name);\n  }\n\n  const rs = new RegexSet(rsPatterns, options);\n\n  return { type: \"regex\", rs, indexMap, nameMap };\n}\n\n/**\n * Build an Aho-Corasick engine from literal patterns.\n */\nfunction buildAcEngine(\n  patterns: ClassifiedPattern[],\n  options: {\n    unicodeBoundaries: boolean;\n    wholeWords: boolean;\n    caseInsensitive: boolean;\n  },\n): AcSlot {\n  const literals: string[] = [];\n  const indexMap: number[] = [];\n  const nameMap: (string | undefined)[] = [];\n\n  for (const cp of patterns) {\n    literals.push(cp.pattern as string);\n    indexMap.push(cp.originalIndex);\n    nameMap.push(cp.name);\n  }\n\n  const ac = new AhoCorasick(literals, {\n    wholeWords: options.wholeWords,\n    unicodeBoundaries: options.unicodeBoundaries,\n    caseInsensitive: options.caseInsensitive,\n  });\n\n  return { type: \"ac\", ac, indexMap, nameMap };\n}\n\n/**\n * Build a FuzzySearch engine from fuzzy patterns.\n */\nfunction buildFuzzyEngine(\n  patterns: ClassifiedPattern[],\n  options: {\n    unicodeBoundaries: boolean;\n    wholeWords: boolean;\n    metric?: \"levenshtein\" | \"damerau-levenshtein\";\n    normalizeDiacritics?: boolean;\n    caseInsensitive?: boolean;\n  },\n): FuzzySlot {\n  const fsPatterns: {\n    pattern: string;\n    distance?: number | \"auto\";\n    name?: string;\n  }[] = [];\n  const indexMap: number[] = [];\n  const nameMap: (string | undefined)[] = [];\n\n  for (const cp of patterns) {\n    const entry: (typeof fsPatterns)[number] = {\n      pattern: cp.pattern as string,\n    };\n    if (cp.fuzzyDistance !== undefined)\n      entry.distance = cp.fuzzyDistance;\n    if (cp.name !== undefined) entry.name = cp.name;\n    fsPatterns.push(entry);\n    indexMap.push(cp.originalIndex);\n    nameMap.push(cp.name);\n  }\n\n  const fsOptions: ConstructorParameters<\n    typeof FuzzySearch\n  >[1] = {\n    unicodeBoundaries: options.unicodeBoundaries,\n    wholeWords: options.wholeWords,\n  };\n  if (options.metric !== undefined)\n    fsOptions.metric = options.metric;\n  if (options.normalizeDiacritics !== undefined)\n    fsOptions.normalizeDiacritics =\n      options.normalizeDiacritics;\n  if (options.caseInsensitive !== undefined)\n    fsOptions.caseInsensitive =\n      options.caseInsensitive;\n  const fs = new FuzzySearch(fsPatterns, fsOptions);\n\n  return { type: \"fuzzy\", fs, indexMap, nameMap };\n}\n\n/**\n * Dispatch isMatch to the correct engine.\n */\nfunction engineIsMatch(\n  engine: EngineSlot,\n  haystack: string,\n): boolean {\n  switch (engine.type) {\n    case \"ac\":\n      return engine.ac.isMatch(haystack);\n    case \"fuzzy\":\n      return engine.fs.isMatch(haystack);\n    case \"regex\":\n      return engine.rs.isMatch(haystack);\n  }\n}\n\n/**\n * Dispatch findIter to the correct engine.\n */\nfunction engineFindIter(\n  engine: EngineSlot,\n  haystack: string,\n): Match[] {\n  switch (engine.type) {\n    case \"ac\":\n      return engine.ac.findIter(haystack);\n    case \"fuzzy\":\n      return engine.fs.findIter(haystack);\n    case \"regex\":\n      return engine.rs.findIter(haystack);\n  }\n}\n\n/**\n * Remap engine-local match indices to original\n * input indices and add names.\n */\nfunction remapMatches(\n  matches: Match[],\n  engine: EngineSlot,\n): Match[] {\n  return matches.map((m) => {\n    const originalIdx =\n      engine.indexMap[m.pattern]!;\n    const name = engine.nameMap[m.pattern];\n    const result: Match = {\n      pattern: originalIdx,\n      start: m.start,\n      end: m.end,\n      text: m.text,\n    };\n    if (name !== undefined) {\n      result.name = name;\n    }\n    // Preserve edit distance from fuzzy matches\n    if (\"distance\" in m && m.distance !== undefined) {\n      result.distance = m.distance as number;\n    }\n    return result;\n  });\n}\n"],"mappings":";;;;;;;;;AA6CA,SAAgB,iBACd,SACS;AAMT,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,KAAK,QAAQ;AACnB,MACE,OAAO,QACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,OACP,OAAO,IAEP,QAAO;;AAGX,QAAO,QAAQ,SAAS;;;;;;;;;;;;;AAc1B,SAAgB,kBACd,SACQ;CACR,IAAI,QAAQ;CACZ,IAAI,UAAU;CACd,IAAI,IAAI;CAKR,IAAI,MAAM;CACV,IAAI,eAAe;CACnB,MAAM,QAAkB,EAAE;AAE1B,QAAO,IAAI,QAAQ,QAAQ;EACzB,MAAM,KAAK,QAAQ;AAEnB,MAAI,OAAO,QAAQ,IAAI,IAAI,QAAQ,QAAQ;AACzC,QAAK;AACL;;AAGF,MAAI,OAAO,IAAK,WAAU;AAC1B,MAAI,OAAO,IAAK,WAAU;AAE1B,MAAI,CAAC,SAAS;AACZ,OAAI,OAAO,KAAK;AACd,UAAM,KAAK,aAAa;AACxB,mBAAe;AACf;;AAEF,OAAI,OAAO,KAAK;AACd,QAAI,eAAe,IAAK,OAAM;AAC9B,mBAAe,MAAM,KAAK,IAAI;AAC9B;;AAEF,OAAI,OAAO,IACT;;AAIJ;;AAGF,KAAI,eAAe,IAAK,OAAM;AAC9B,QAAO;;;;;AAMT,SAAgB,iBACd,SACA,aAAa,OACQ;AACrB,QAAO,QAAQ,KAAK,OAAO,MAAM;AAC/B,MAAI,OAAO,UAAU,SACnB,QAAO;GACL,eAAe;GACf,SAAS;GACT,kBAAkB,aACd,IACA,kBAAkB,MAAM;GAC5B,WAAW,cACT,iBAAiB,MAAM;GAC1B;AAGH,MAAI,iBAAiB,OACnB,QAAO;GACL,eAAe;GACf,SAAS;GACT,kBAAkB,kBAChB,MAAM,OACP;GACD,WAAW;GACZ;AAIH,MAAI,cAAc,OAAO;GACvB,MAAM,SAA4B;IAChC,eAAe;IACf,SAAS,MAAM;IACf,kBAAkB;IAClB,WAAW;IACX,eAAe,MAAM;IACtB;AACD,OAAI,MAAM,SAAS,KAAA,EAAW,QAAO,OAAO,MAAM;AAClD,UAAO;;AAIT,MAAI,aAAa,SAAS,MAAM,SAAS;GACvC,MAAM,oBACJ,qBAAqB,SACrB,gBAAgB;GAClB,MAAM,SAA4B;IAChC,eAAe;IACf,SAAS,MAAM;IACf,kBAAkB;IAClB,WAAW;IACZ;AACD,OAAI,MAAM,SAAS,KAAA,EAAW,QAAO,OAAO,MAAM;AAClD,OAAI,mBAAmB;IACrB,MAAM,OAEF,EAAE;AACN,QAAI,MAAM,oBAAoB,KAAA,EAC5B,MAAK,kBAAkB,MAAM;AAC/B,QAAI,MAAM,eAAe,KAAA,EACvB,MAAK,aAAa,MAAM;AAC1B,WAAO,YAAY;;AAErB,UAAO;;EAGT,MAAM,MAAM,MAAM;EAClB,MAAM,SACJ,eAAe,SAAS,IAAI,SAAS;EAEvC,MAAM,SAA4B;GAChC,eAAe;GACf,SAAS;GACT,kBAAkB,aACd,IACA,kBAAkB,OAAO;GAC7B,WACE,OAAO,QAAQ,aACd,cAAc,iBAAiB,IAAI;GACvC;AACD,MAAI,MAAM,SAAS,KAAA,EAAW,QAAO,OAAO,MAAM;AAClD,SAAO;GACP;;;;;;;;;;ACrNJ,SAAgB,eACd,SACS;AACT,KAAI,QAAQ,UAAU,EAAG,QAAO;AAGhC,SAAQ,MAAM,GAAG,MAAM;AACrB,MAAI,EAAE,UAAU,EAAE,MAChB,QAAO,EAAE,QAAQ,EAAE;AAErB,SAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE;GACpC;CAGF,MAAM,WAAoB,EAAE;CAC5B,IAAI,UAAU;AAEd,MAAK,MAAM,KAAK,QACd,KAAI,EAAE,SAAS,SAAS;AACtB,WAAS,KAAK,EAAE;AAChB,YAAU,EAAE;;AAIhB,QAAO;;;;;;;;;;;;;;;;;ACoBT,IAAa,aAAb,MAAwB;CACtB,UAAgC,EAAE;CAClC;CACA;;;;;;;CAOA,eAAgC;CAEhC,YACE,UACA,SACA;AACA,OAAK,eAAe,SAAS;AAC7B,OAAK,aACH,SAAS,oBAAoB;EAC/B,MAAM,SAAS,SAAS,mBAAmB;EAC3C,MAAM,aAAa,iBACjB,UACA,SAAS,cAAc,MACxB;EAOD,MAAM,QAA6B,EAAE;EACrC,MAAM,WAAgC,EAAE;EACxC,MAAM,SAA8B,EAAE;EACtC,MAAM,WAAgC,EAAE;AAExC,OAAK,MAAM,MAAM,WACf,KAAI,GAAG,kBAAkB,KAAA,EACvB,OAAM,KAAK,GAAG;WACL,GAAG,UACZ,UAAS,KAAK,GAAG;WACR,GAAG,mBAAmB,OAC/B,UAAS,KAAK,GAAG;MAEjB,QAAO,KAAK,GAAG;EAInB,MAAM,YAAY;GAChB,mBACE,SAAS,qBAAqB;GAChC,YAAY,SAAS,cAAc;GACnC,iBACE,SAAS,mBAAmB;GAC/B;AAGD,MAAI,MAAM,SAAS,GAAG;GACpB,MAAM,YAEC;IACL,mBACE,UAAU;IACZ,YAAY,UAAU;IACvB;AACD,OAAI,SAAS,gBAAgB,KAAA,EAC3B,WAAU,SAAS,QAAQ;AAC7B,OAAI,SAAS,wBAAwB,KAAA,EACnC,WAAU,sBACR,QAAQ;AACZ,OAAI,SAAS,oBAAoB,KAAA,EAC/B,WAAU,kBACR,QAAQ;AACZ,QAAK,QAAQ,KACX,iBAAiB,OAAO,UAAU,CACnC;;AAOH,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,yBAAS,IAAI,KAGhB;AACH,QAAK,MAAM,MAAM,UAAU;IACzB,MAAM,KACJ,GAAG,WAAW,mBACd,UAAU;IACZ,MAAM,KACJ,GAAG,WAAW,cACd,UAAU;IACZ,MAAM,MAAM,GAAG,KAAK,IAAI,EAAE,GAAG,KAAK,IAAI;IACtC,MAAM,QAAQ,OAAO,IAAI,IAAI;AAC7B,QAAI,MACF,OAAM,KAAK,GAAG;QAEd,QAAO,IAAI,KAAK,CAAC,GAAG,CAAC;;AAGzB,QAAK,MAAM,CAAC,KAAK,UAAU,QAAQ;IACjC,MAAM,CAAC,IAAI,MAAM,IAAI,MAAM,IAAI;AAC/B,SAAK,QAAQ,KACX,cAAc,OAAO;KACnB,GAAG;KACH,iBAAiB,OAAO;KACxB,YAAY,OAAO;KACpB,CAAC,CACH;;;AAQL,MAAI,OAAO,SAAS,GAAG;GACrB,MAAM,WAAW,iBACf,QACA,UACD;GAED,MAAM,QACJ,+FAGA,OAAO,GAAG;GACZ,MAAM,KAAK,YAAY,KAAK;AAC5B,YAAS,GAAG,SAAS,MAAM;GAC3B,MAAM,aAAa,YAAY,KAAK,GAAG;GAGvC,IAAI,eAAe;GACnB,MAAM,oBAAiC,EAAE;AACzC,QAAK,MAAM,MAAM,QAAQ;IACvB,MAAM,MAAM,iBACV,CAAC,GAAG,EACJ,UACD;IACD,MAAM,KAAK,YAAY,KAAK;AAC5B,QAAI,GAAG,SAAS,MAAM;AACtB,oBAAgB,YAAY,KAAK,GAAG;AACpC,sBAAkB,KAAK,IAAI;;AAG7B,OAAI,aAAa,eAAe,IAE9B,MAAK,MAAM,OAAO,kBAChB,MAAK,QAAQ,KAAK,IAAI;OAGxB,MAAK,QAAQ,KAAK,SAAS;aAEpB,OAAO,WAAW,EAC3B,MAAK,QAAQ,KACX,iBAAiB,QAAQ,UAAU,CACpC;AAGH,OAAK,MAAM,MAAM,SACf,MAAK,QAAQ,KACX,iBAAiB,CAAC,GAAG,EAAE,UAAU,CAClC;AAQH,MAAI,KAAK,QAAQ,WAAW;OAKtB,CAJW,KAAK,QAAQ,GACJ,QAAQ,MAC7B,MAAM,MAAM,KAAA,EACd,CAEC,MAAK,eAAe;;;;CAM1B,IAAI,SAAiB;AACnB,SAAO,KAAK;;;CAId,QAAQ,UAA2B;AACjC,OAAK,MAAM,UAAU,KAAK,QACxB,KAAI,cAAc,QAAQ,SAAS,CACjC,QAAO;AAGX,SAAO;;;;;;;;;;;CAYT,SAAS,UAA2B;AAIlC,MAAI,KAAK,aACP,QAAO,eACL,KAAK,QAAQ,IACb,SACD;AAIH,MAAI,KAAK,QAAQ,WAAW,EAC1B,QAAO,aACL,eAAe,KAAK,QAAQ,IAAK,SAAS,EAC1C,KAAK,QAAQ,GACd;EAIH,MAAM,MAAe,EAAE;AACvB,OAAK,MAAM,UAAU,KAAK,SAAS;GACjC,MAAM,UAAU,eACd,QACA,SACD;AAED,QAAK,MAAM,KAAK,aAAa,SAAS,OAAO,CAC3C,KAAI,KAAK,EAAE;;AAIf,MAAI,KAAK,WACP,QAAO,IAAI,MACR,GAAG,MAAM,EAAE,QAAQ,EAAE,MACvB;AAGH,SAAO,eAAe,IAAI;;;CAI5B,WAAW,UAA4B;EACrC,MAAM,uBAAO,IAAI,KAAa;AAE9B,OAAK,MAAM,UAAU,KAAK,SAAS;GAEjC,MAAM,UAAU,eACd,QACA,SACD;AACD,QAAK,MAAM,KAAK,QACd,MAAK,IAAI,OAAO,SAAS,EAAE,SAAU;;AAIzC,SAAO,CAAC,GAAG,KAAK;;;;;;CAOlB,WACE,UACA,cACQ;AACR,MAAI,aAAa,WAAW,KAAK,aAC/B,OAAM,IAAI,MACR,YAAY,KAAK,aAAa,qBACP,aAAa,SACrC;EAKH,MAAM,MAAe,EAAE;AACvB,OAAK,MAAM,UAAU,KAAK,SAAS;GACjC,MAAM,UAAU,eACd,QACA,SACD;AACD,QAAK,MAAM,KAAK,aAAa,SAAS,OAAO,CAC3C,KAAI,KAAK,EAAE;;EAGf,MAAM,UAAU,eAAe,IAAI;EAEnC,IAAI,SAAS;EACb,IAAI,OAAO;AAEX,OAAK,MAAM,KAAK,SAAS;AACvB,aAAU,SAAS,MAAM,MAAM,EAAE,MAAM;AACvC,aAAU,aAAa,EAAE;AACzB,UAAO,EAAE;;AAGX,YAAU,SAAS,MAAM,KAAK;AAC9B,SAAO;;;;;;AAOX,SAAS,iBACP,UACA,SAKW;CACX,MAAM,aAGC,EAAE;CACT,MAAM,WAAqB,EAAE;CAC7B,MAAM,UAAkC,EAAE;AAE1C,MAAK,MAAM,MAAM,UAAU;AACzB,MAAI,GAAG,SAAS,KAAA,EACd,YAAW,KAAK;GACd,SAAS,GAAG;GACZ,MAAM,GAAG;GACV,CAAC;MAEF,YAAW,KAAK,GAAG,QAAQ;AAE7B,WAAS,KAAK,GAAG,cAAc;AAC/B,UAAQ,KAAK,GAAG,KAAK;;AAKvB,QAAO;EAAE,MAAM;EAAS,IAFb,IAAI,SAAS,YAAY,QAAQ;EAEhB;EAAU;EAAS;;;;;AAMjD,SAAS,cACP,UACA,SAKQ;CACR,MAAM,WAAqB,EAAE;CAC7B,MAAM,WAAqB,EAAE;CAC7B,MAAM,UAAkC,EAAE;AAE1C,MAAK,MAAM,MAAM,UAAU;AACzB,WAAS,KAAK,GAAG,QAAkB;AACnC,WAAS,KAAK,GAAG,cAAc;AAC/B,UAAQ,KAAK,GAAG,KAAK;;AASvB,QAAO;EAAE,MAAM;EAAM,IANV,IAAI,YAAY,UAAU;GACnC,YAAY,QAAQ;GACpB,mBAAmB,QAAQ;GAC3B,iBAAiB,QAAQ;GAC1B,CAAC;EAEuB;EAAU;EAAS;;;;;AAM9C,SAAS,iBACP,UACA,SAOW;CACX,MAAM,aAIA,EAAE;CACR,MAAM,WAAqB,EAAE;CAC7B,MAAM,UAAkC,EAAE;AAE1C,MAAK,MAAM,MAAM,UAAU;EACzB,MAAM,QAAqC,EACzC,SAAS,GAAG,SACb;AACD,MAAI,GAAG,kBAAkB,KAAA,EACvB,OAAM,WAAW,GAAG;AACtB,MAAI,GAAG,SAAS,KAAA,EAAW,OAAM,OAAO,GAAG;AAC3C,aAAW,KAAK,MAAM;AACtB,WAAS,KAAK,GAAG,cAAc;AAC/B,UAAQ,KAAK,GAAG,KAAK;;CAGvB,MAAM,YAEC;EACL,mBAAmB,QAAQ;EAC3B,YAAY,QAAQ;EACrB;AACD,KAAI,QAAQ,WAAW,KAAA,EACrB,WAAU,SAAS,QAAQ;AAC7B,KAAI,QAAQ,wBAAwB,KAAA,EAClC,WAAU,sBACR,QAAQ;AACZ,KAAI,QAAQ,oBAAoB,KAAA,EAC9B,WAAU,kBACR,QAAQ;AAGZ,QAAO;EAAE,MAAM;EAAS,IAFb,IAAI,YAAY,YAAY,UAAU;EAErB;EAAU;EAAS;;;;;AAMjD,SAAS,cACP,QACA,UACS;AACT,SAAQ,OAAO,MAAf;EACE,KAAK,KACH,QAAO,OAAO,GAAG,QAAQ,SAAS;EACpC,KAAK,QACH,QAAO,OAAO,GAAG,QAAQ,SAAS;EACpC,KAAK,QACH,QAAO,OAAO,GAAG,QAAQ,SAAS;;;;;;AAOxC,SAAS,eACP,QACA,UACS;AACT,SAAQ,OAAO,MAAf;EACE,KAAK,KACH,QAAO,OAAO,GAAG,SAAS,SAAS;EACrC,KAAK,QACH,QAAO,OAAO,GAAG,SAAS,SAAS;EACrC,KAAK,QACH,QAAO,OAAO,GAAG,SAAS,SAAS;;;;;;;AAQzC,SAAS,aACP,SACA,QACS;AACT,QAAO,QAAQ,KAAK,MAAM;EACxB,MAAM,cACJ,OAAO,SAAS,EAAE;EACpB,MAAM,OAAO,OAAO,QAAQ,EAAE;EAC9B,MAAM,SAAgB;GACpB,SAAS;GACT,OAAO,EAAE;GACT,KAAK,EAAE;GACP,MAAM,EAAE;GACT;AACD,MAAI,SAAS,KAAA,EACX,QAAO,OAAO;AAGhB,MAAI,cAAc,KAAK,EAAE,aAAa,KAAA,EACpC,QAAO,WAAW,EAAE;AAEtB,SAAO;GACP"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/text-search",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Multi-engine text search orchestrator. Routes patterns to optimal engines: Aho-Corasick, RegexSet, or FuzzySearch.",
   "keywords": [
     "text-search",
@@ -35,23 +35,23 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "prepublishOnly": "bun run build",
     "test": "bun test",
     "lint": "oxlint .",
     "format": "oxfmt ."
   },
   "dependencies": {
-    "@stll/aho-corasick": "^0.2.0",
-    "@stll/fuzzy-search": "^0.1.0",
-    "@stll/regex-set": "^0.4.0"
+    "@stll/aho-corasick": "^0.3.0",
+    "@stll/fuzzy-search": "^0.2.0",
+    "@stll/regex-set": "^0.5.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "bun-types": "^1.3.10",
     "oxfmt": "^0.40.0",
     "oxlint": "^1.55.0",
-    "tsup": "^8.5.1",
+    "tsdown": "^0.12.4",
     "typescript": "^5.9.3"
   },
   "engines": {

package/dist/index.d.ts

@@ -1,150 +0,0 @@
-/**
- * A single match result. Same shape as
- * @stll/regex-set and @stll/aho-corasick.
- */
-type Match = {
-    /** Index of the pattern that matched. */
-    pattern: number;
-    /** Start UTF-16 code unit offset. */
-    start: number;
-    /** End offset (exclusive). */
-    end: number;
-    /** The matched text. */
-    text: string;
-    /** Pattern name (if provided). */
-    name?: string;
-    /** Edit distance (fuzzy matches only). */
-    distance?: number;
-};
-/** A pattern entry for TextSearch. */
-type PatternEntry = string | RegExp | {
-    pattern: string | RegExp;
-    name?: string;
-} | {
-    pattern: string;
-    name?: string;
-    /** Fuzzy matching distance. Routes to
-     *  @stll/fuzzy-search instead of regex. */
-    distance: number | "auto";
-} | {
-    pattern: string;
-    name?: string;
-    /** Force literal matching via Aho-Corasick.
-     *  Skips regex metacharacter detection so
-     *  patterns like "č.p." or "s.r.o." are
-     *  matched literally, not as regex. */
-    literal: true;
-    /** Per-pattern case-insensitive for AC.
-     *  Overrides the global option for this
-     *  pattern only. */
-    caseInsensitive?: boolean;
-    /** Per-pattern whole-word matching for AC. */
-    wholeWords?: boolean;
-};
-/** Options for TextSearch. */
-type TextSearchOptions = {
-    /**
-     * Use Unicode word boundaries.
-     * @default true
-     */
-    unicodeBoundaries?: boolean;
-    /**
-     * Only match whole words.
-     * @default false
-     */
-    wholeWords?: boolean;
-    /**
-     * Max alternation branches before auto-splitting
-     * into a separate engine instance. Prevents DFA
-     * state explosion when large-alternation patterns
-     * are combined with other patterns.
-     * @default 50
-     */
-    maxAlternations?: number;
-    /**
-     * Fuzzy matching metric.
-     * @default "levenshtein"
-     */
-    fuzzyMetric?: "levenshtein" | "damerau-levenshtein";
-    /**
-     * Normalize diacritics for fuzzy matching.
-     * @default false
-     */
-    normalizeDiacritics?: boolean;
-    /**
-     * Case-insensitive matching for AC literals
-     * and fuzzy patterns.
-     * @default false
-     */
-    caseInsensitive?: boolean;
-    /**
-     * How to handle overlapping matches from
-     * different engines or patterns.
-     *
-     * - "longest": keep longest non-overlapping match
-     *   at each position (default).
-     * - "all": return all matches including overlaps.
-     *   Useful when the caller applies its own dedup.
-     *
-     * @default "longest"
-     */
-    overlapStrategy?: "longest" | "all";
-    /**
-     * Treat ALL string patterns as literals (route
-     * to AC, skip metacharacter detection). Useful
-     * for deny-list patterns where "s.r.o." means
-     * the literal string, not a regex with wildcards.
-     * @default false
-     */
-    allLiteral?: boolean;
-};
-
-/**
- * Multi-engine text search orchestrator.
- *
- * Routes patterns to the optimal engine
- * configuration:
- * - Large alternation patterns get their own
- *   RegexSet instance (prevents DFA state explosion)
- * - Normal patterns share a single RegexSet
- *   (single-pass multi-pattern DFA)
- *
- * Merges results from all engines into a unified
- * non-overlapping Match[] sorted by position.
- */
-declare class TextSearch {
-    private engines;
-    private patternCount;
-    private overlapAll;
-    /**
-     * True when there's exactly one engine and all
-     * patterns map to identity indices (0→0, 1→1, ...).
-     * Enables zero-overhead findIter: return raw engine
-     * output without remapping or object allocation.
-     */
-    private zeroOverhead;
-    constructor(patterns: PatternEntry[], options?: TextSearchOptions);
-    /** Number of patterns. */
-    get length(): number;
-    /** Returns true if any pattern matches. */
-    isMatch(haystack: string): boolean;
-    /**
-     * Find matches in text.
-     *
-     * With `overlapStrategy: "longest"` (default):
-     * returns non-overlapping matches, longest wins.
-     *
-     * With `overlapStrategy: "all"`: returns all
-     * matches including overlaps, sorted by position.
-     */
-    findIter(haystack: string): Match[];
-    /** Which pattern indices matched (not where). */
-    whichMatch(haystack: string): number[];
-    /**
-     * Replace all non-overlapping matches.
-     * replacements[i] replaces pattern i.
-     */
-    replaceAll(haystack: string, replacements: string[]): string;
-}
-
-export { type Match, type PatternEntry, TextSearch, type TextSearchOptions };