@stll/text-search 0.1.1 → 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

@@ -0,0 +1,414 @@
+import { AhoCorasick } from "@stll/aho-corasick";
+import { FuzzySearch } from "@stll/fuzzy-search";
+import { RegexSet } from "@stll/regex-set";
+//#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;
+}
+/**
+* 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;
+}
+/**
+* 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
+		};
+		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;
+	});
+}
+//#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;
+}
+//#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á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);
+	}
+	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);
+	}
+	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;
+	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);
+	}
+}
+/**
+* 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);
+	}
+}
+/**
+* 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;
+	});
+}
+//#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.1.1",
+  "version": "0.3.0",
   "description": "Multi-engine text search orchestrator. Routes patterns to optimal engines: Aho-Corasick, RegexSet, or FuzzySearch.",
   "keywords": [
     "text-search",
@@ -20,30 +20,39 @@
     "url": "https://github.com/stella/text-search"
   },
   "type": "module",
-  "main": "src/index.ts",
-  "module": "src/index.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "src"
+    "src",
+    "dist"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node",
+    "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"
+    "oxlint": "^1.55.0",
+    "tsdown": "^0.12.4",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">= 18"

package/src/classify.ts

@@ -167,14 +167,15 @@ export function classifyPatterns(
 
     // Fuzzy pattern: has `distance` field
     if ("distance" in entry) {
-      return {
+      const result: ClassifiedPattern = {
         originalIndex: i,
         pattern: entry.pattern,
-        name: entry.name,
         alternationCount: 0,
         isLiteral: false,
         fuzzyDistance: entry.distance,
       };
+      if (entry.name !== undefined) result.name = entry.name;
+      return result;
     }
 
     // Explicit literal: skip metachar detection
@@ -182,30 +183,33 @@ export function classifyPatterns(
       const hasPerPatternOpts =
         "caseInsensitive" in entry ||
         "wholeWords" in entry;
-      return {
+      const result: ClassifiedPattern = {
         originalIndex: i,
         pattern: entry.pattern,
-        name: entry.name,
         alternationCount: 0,
         isLiteral: true,
-        acOptions: hasPerPatternOpts
-          ? {
-              caseInsensitive:
-                entry.caseInsensitive,
-              wholeWords: entry.wholeWords,
-            }
-          : undefined,
       };
+      if (entry.name !== undefined) result.name = entry.name;
+      if (hasPerPatternOpts) {
+        const opts: NonNullable<
+          ClassifiedPattern["acOptions"]
+        > = {};
+        if (entry.caseInsensitive !== undefined)
+          opts.caseInsensitive = entry.caseInsensitive;
+        if (entry.wholeWords !== undefined)
+          opts.wholeWords = entry.wholeWords;
+        result.acOptions = opts;
+      }
+      return result;
     }
 
     const pat = entry.pattern;
     const source =
       pat instanceof RegExp ? pat.source : pat;
 
-    return {
+    const result: ClassifiedPattern = {
       originalIndex: i,
       pattern: pat,
-      name: entry.name,
       alternationCount: allLiteral
         ? 0
         : countAlternations(source),
@@ -213,5 +217,7 @@ export function classifyPatterns(
         typeof pat === "string" &&
         (allLiteral || isLiteralPattern(pat)),
     };
+    if (entry.name !== undefined) result.name = entry.name;
+    return result;
   });
 }

package/src/text-search.ts

@@ -107,17 +107,23 @@ export class TextSearch {
 
     // Build fuzzy engine
     if (fuzzy.length > 0) {
+      const fuzzyOpts: Parameters<
+        typeof buildFuzzyEngine
+      >[1] = {
+        unicodeBoundaries:
+          rsOptions.unicodeBoundaries,
+        wholeWords: rsOptions.wholeWords,
+      };
+      if (options?.fuzzyMetric !== undefined)
+        fuzzyOpts.metric = options.fuzzyMetric;
+      if (options?.normalizeDiacritics !== undefined)
+        fuzzyOpts.normalizeDiacritics =
+          options.normalizeDiacritics;
+      if (options?.caseInsensitive !== undefined)
+        fuzzyOpts.caseInsensitive =
+          options.caseInsensitive;
       this.engines.push(
-        buildFuzzyEngine(fuzzy, {
-          unicodeBoundaries:
-            rsOptions.unicodeBoundaries,
-          wholeWords: rsOptions.wholeWords,
-          metric: options?.fuzzyMetric,
-          normalizeDiacritics:
-            options?.normalizeDiacritics,
-          caseInsensitive:
-            options?.caseInsensitive,
-        }),
+        buildFuzzyEngine(fuzzy, fuzzyOpts),
       );
     }
 
@@ -440,23 +446,32 @@ function buildFuzzyEngine(
   const nameMap: (string | undefined)[] = [];
 
   for (const cp of patterns) {
-    fsPatterns.push({
+    const entry: (typeof fsPatterns)[number] = {
       pattern: cp.pattern as string,
-      distance: cp.fuzzyDistance,
-      name: cp.name,
-    });
+    };
+    if (cp.fuzzyDistance !== undefined)
+      entry.distance = cp.fuzzyDistance;
+    if (cp.name !== undefined) entry.name = cp.name;
+    fsPatterns.push(entry);
     indexMap.push(cp.originalIndex);
     nameMap.push(cp.name);
   }
 
-  const fs = new FuzzySearch(fsPatterns, {
+  const fsOptions: ConstructorParameters<
+    typeof FuzzySearch
+  >[1] = {
     unicodeBoundaries: options.unicodeBoundaries,
     wholeWords: options.wholeWords,
-    metric: options.metric,
-    normalizeDiacritics:
-      options.normalizeDiacritics,
-    caseInsensitive: options.caseInsensitive,
-  });
+  };
+  if (options.metric !== undefined)
+    fsOptions.metric = options.metric;
+  if (options.normalizeDiacritics !== undefined)
+    fsOptions.normalizeDiacritics =
+      options.normalizeDiacritics;
+  if (options.caseInsensitive !== undefined)
+    fsOptions.caseInsensitive =
+      options.caseInsensitive;
+  const fs = new FuzzySearch(fsPatterns, fsOptions);
 
   return { type: "fuzzy", fs, indexMap, nameMap };
 }