quickmatch-js 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickmatch-js",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Lightning-fast fuzzy string matching",
   "type": "module",
   "main": "src/index.js",

package/src/config.rs

@@ -1,11 +1,12 @@
-const DEFAULT_SEPARATORS: &[char] = &['_', '-', ' '];
+const DEFAULT_SEPARATORS: &[char] = &['_', '-', ' ', ':', '/'];
 const DEFAULT_TRIGRAM_BUDGET: usize = 6;
 const DEFAULT_LIMIT: usize = 100;
+const DEFAULT_MIN_SCORE: usize = 2;
 
 pub struct QuickMatchConfig {
     /// Separators used to split words.
     ///
-    /// Default: ['_', '-', ' ']
+    /// Default: ['_', '-', ' ', ':', '/']
     separators: &'static [char],
     /// Maximum number of results to return.
     ///
@@ -22,6 +23,12 @@ pub struct QuickMatchConfig {
     /// - High (9-15): Slower, more accurate fuzzy matching
     /// - Max: 20
     trigram_budget: usize,
+    /// Minimum trigram score required for fuzzy matches.
+    /// Higher values require more trigram overlap, reducing noise.
+    ///
+    /// Default: 2
+    /// - Min: 1
+    min_score: usize,
 }
 
 impl Default for QuickMatchConfig {
@@ -30,6 +37,7 @@ impl Default for QuickMatchConfig {
             separators: DEFAULT_SEPARATORS,
             limit: DEFAULT_LIMIT,
             trigram_budget: DEFAULT_TRIGRAM_BUDGET,
+            min_score: DEFAULT_MIN_SCORE,
         }
     }
 }
@@ -54,6 +62,11 @@ impl QuickMatchConfig {
         self
     }
 
+    pub fn with_min_score(mut self, min_score: usize) -> Self {
+        self.min_score = min_score.max(1);
+        self
+    }
+
     pub fn limit(&self) -> usize {
         self.limit
     }
@@ -65,4 +78,8 @@ impl QuickMatchConfig {
     pub fn separators(&self) -> &[char] {
         self.separators
     }
+
+    pub fn min_score(&self) -> usize {
+        self.min_score
+    }
 }

package/src/index.js

@@ -1,335 +1,426 @@
-const DEFAULT_SEPARATORS = '_- ';
+const DEFAULT_SEPARATORS = "_- :/";
 const DEFAULT_TRIGRAM_BUDGET = 6;
 const DEFAULT_LIMIT = 100;
+const DEFAULT_MIN_SCORE = 2;
 
+/**
+ * Configuration for QuickMatch.
+ */
 export class QuickMatchConfig {
+  /**
+   * Separators used to split words.
+   * @type {string}
+   * @default "_- :/"
+   */
   separators = DEFAULT_SEPARATORS;
+
+  /**
+   * Maximum number of results to return.
+   * @type {number}
+   * @default 100
+   */
   limit = DEFAULT_LIMIT;
+
+  /**
+   * Budget of trigrams to process from unknown words.
+   * This budget is distributed fairly across all unknown words.
+   *
+   * - 0: Disable trigram matching (only exact word matches)
+   * - Low (3-6): Faster, less accurate fuzzy matching
+   * - High (9-15): Slower, more accurate fuzzy matching
+   * - Max: 20
+   * @type {number}
+   * @default 6
+   */
   trigramBudget = DEFAULT_TRIGRAM_BUDGET;
 
+  /**
+   * Minimum trigram score required for fuzzy matches.
+   * Higher values require more trigram overlap, reducing noise.
+   * @type {number}
+   * @default 2
+   */
+  minScore = DEFAULT_MIN_SCORE;
+
+  /** @param {number} n - Max results (default: 100, min: 1) */
   withLimit(n) {
     this.limit = Math.max(1, n);
     return this;
   }
 
+  /** @param {number} n - Trigram budget (0-20, default: 6) */
   withTrigramBudget(n) {
     this.trigramBudget = Math.max(0, Math.min(20, n));
     return this;
   }
 
+  /** @param {string} s - Separator characters (default: '_- :/') */
   withSeparators(s) {
     this.separators = s;
     return this;
   }
+
+  /** @param {number} n - Min trigram score (default: 2, min: 1) */
+  withMinScore(n) {
+    this.minScore = Math.max(1, n);
+    return this;
+  }
 }
 
+/**
+ * Fast fuzzy string matcher using word and trigram indexing.
+ */
 export class QuickMatch {
+  /**
+   * @param {string[]} items - Items to index (should be lowercase)
+   * @param {QuickMatchConfig} [config]
+   */
   constructor(items, config = new QuickMatchConfig()) {
     this.config = config;
     this.items = items;
+    /** @type {Map<string, number[]>} */
     this.wordIndex = new Map();
+    /** @type {Map<string, number[]>} */
     this.trigramIndex = new Map();
+    this._sepLookup = sepLookup(config.separators);
+    this._scores = new Uint32Array(items.length);
+    /** @type {number[]} */
+    this._dirty = [];
 
-    let maxWordLength = 0;
-    let maxQueryLength = 0;
-    let maxWordCount = 0;
-
-    const { separators } = config;
+    let maxWordLen = 0;
+    let maxQueryLen = 0;
+    let maxWords = 0;
+    const sep = this._sepLookup;
 
-    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-      const item = items[itemIndex];
-
-      if (item.length > maxQueryLength) {
-        maxQueryLength = item.length;
-      }
+    for (let idx = 0; idx < items.length; idx++) {
+      const item = items[idx];
+      if (item.length > maxQueryLen) maxQueryLen = item.length;
 
-      let wordCount = 0;
-      let wordStart = 0;
+      const words = [];
+      let start = 0;
 
       for (let i = 0; i <= item.length; i++) {
-        const isEndOfWord = i === item.length || separators.includes(item[i]);
-
-        if (isEndOfWord && i > wordStart) {
-          wordCount++;
-          const word = item.slice(wordStart, i);
-
-          if (word.length > maxWordLength) {
-            maxWordLength = word.length;
-          }
-
-          addToIndex(this.wordIndex, word, itemIndex);
-          addTrigramsToIndex(this.trigramIndex, word, itemIndex);
-
-          wordStart = i + 1;
-        } else if (isEndOfWord) {
-          wordStart = i + 1;
+        if (i < item.length && !sep[item.charCodeAt(i)]) continue;
+        if (i > start) {
+          const word = item.slice(start, i);
+          words.push(word);
+          if (word.length > maxWordLen) maxWordLen = word.length;
+          addToIndex(this.wordIndex, word, idx);
+          indexTrigrams(this.trigramIndex, word, idx);
         }
+        start = i + 1;
       }
 
-      if (wordCount > maxWordCount) {
-        maxWordCount = wordCount;
+      for (let i = 0; i < words.length - 1; i++) {
+        addToIndex(this.wordIndex, words[i] + words[i + 1], idx);
       }
+
+      if (words.length > maxWords) maxWords = words.length;
     }
 
-    this.maxWordLength = maxWordLength + 4;
-    this.maxQueryLength = maxQueryLength + 6;
-    this.maxWordCount = maxWordCount + 2;
+    this.maxWordLen = maxWordLen + 4;
+    this.maxQueryLen = maxQueryLen + 6;
+    this.maxWords = maxWords + 2;
   }
 
+  /** @param {string} query */
   matches(query) {
     return this.matchesWith(query, this.config);
   }
 
+  /**
+   * @param {string} query
+   * @param {QuickMatchConfig} config
+   */
   matchesWith(query, config) {
-    const { limit, trigramBudget, separators } = config;
+    const { limit, trigramBudget } = config;
+    const sep =
+      config.separators === this.config.separators
+        ? this._sepLookup
+        : sepLookup(config.separators);
 
-    const normalizedQuery = normalizeQuery(query);
+    const q = normalize(query);
+    if (!q || q.length > this.maxQueryLen) return [];
 
-    if (!normalizedQuery || normalizedQuery.length > this.maxQueryLength) {
-      return [];
-    }
+    const qwords = splitWords(q, sep, this.maxWordLen);
+    if (!qwords.length || qwords.length > this.maxWords) return [];
 
-    const queryWords = parseWords(normalizedQuery, separators, this.maxWordLength);
+    const known = [];
+    const unknown = [];
 
-    if (!queryWords.length || queryWords.length > this.maxWordCount) {
-      return [];
+    for (const w of qwords) {
+      const hits = this.wordIndex.get(w);
+      if (hits) known.push(hits);
+      else if (w.length >= 3 && unknown.length < trigramBudget) unknown.push(w);
     }
 
-    const knownWords = [];
-    const unknownWords = [];
+    const pool = intersect(known);
+    const hasPool = pool.length > 0;
 
-    for (const word of queryWords) {
-      const matchingItems = this.wordIndex.get(word);
-
-      if (matchingItems) {
-        knownWords.push(matchingItems);
-      } else if (word.length >= 3 && unknownWords.length < trigramBudget) {
-        unknownWords.push(word);
-      }
+    if (!unknown.length || !trigramBudget) {
+      if (!hasPool) return [];
+      return this._rank(pool, null, qwords, sep, limit);
     }
 
-    const exactMatches = intersectAll(knownWords);
-    const hasExactMatches = exactMatches.length > 0;
-    const needsFuzzyMatching = unknownWords.length > 0 && trigramBudget > 0;
-
-    if (!needsFuzzyMatching) {
-      if (!hasExactMatches) return [];
-      return this.sortedByLength(exactMatches, limit);
-    }
-
-    const scores = new Map();
-
-    if (hasExactMatches) {
-      for (const index of exactMatches) {
-        scores.set(index, 1);
+    // Seed scores from exact-match pool
+    const { _scores: scores, _dirty: dirty } = this;
+    if (hasPool) {
+      for (const i of pool) {
+        scores[i] = 1;
+        dirty.push(i);
       }
     }
 
-    const minItemLength = Math.max(0, normalizedQuery.length - 3);
-
-    const trigramCount = this.scoreByTrigrams({
-      unknownWords,
-      budget: trigramBudget,
-      scores,
-      hasExactMatches,
-      minItemLength,
-    });
-
-    const minScoreToInclude = Math.max(1, Math.ceil(trigramCount / 2));
-
-    return this.rankedResults(scores, minScoreToInclude, limit);
+    const hitCount = this._scoreTrigrams(
+      unknown,
+      trigramBudget,
+      hasPool,
+      Math.max(0, q.length - 3),
+    );
+    const minScore = Math.max(config.minScore, Math.ceil(hitCount / 2));
+    const result = this._rank(dirty, minScore, qwords, sep, limit);
+
+    for (const i of dirty) scores[i] = 0;
+    dirty.length = 0;
+    return result;
   }
 
-  scoreByTrigrams({ unknownWords, budget, scores, hasExactMatches, minItemLength }) {
-    const visitedTrigrams = new Set();
-    let budgetRemaining = budget;
-    let hitCount = 0;
-
-    outer:
-    for (let round = 0; round < budget; round++) {
-      for (const word of unknownWords) {
-        if (budgetRemaining <= 0) break outer;
-
-        const position = pickTrigramPosition(word.length, round);
-        if (position < 0) continue;
-
-        const trigram = word[position] + word[position + 1] + word[position + 2];
-
-        if (visitedTrigrams.has(trigram)) continue;
-        visitedTrigrams.add(trigram);
-
-        budgetRemaining--;
-
-        const matchingItems = this.trigramIndex.get(trigram);
-        if (!matchingItems) continue;
-
-        hitCount++;
-
-        for (const itemIndex of matchingItems) {
-          if (hasExactMatches) {
-            const currentScore = scores.get(itemIndex);
-            if (currentScore !== undefined) {
-              scores.set(itemIndex, currentScore + 1);
+  /**
+   * @private
+   * @param {string[]} unknown
+   * @param {number} budget
+   * @param {boolean} poolOnly
+   * @param {number} minLen
+   */
+  _scoreTrigrams(unknown, budget, poolOnly, minLen) {
+    const visited = new Set();
+    const { _scores: scores, _dirty: dirty, items } = this;
+    let remaining = budget;
+    let hits = 0;
+
+    outer: for (let round = 0; round < budget; round++) {
+      for (const word of unknown) {
+        if (remaining <= 0) break outer;
+
+        const pos = trigramPosition(word.length, round);
+        if (pos < 0) continue;
+
+        const tri = word[pos] + word[pos + 1] + word[pos + 2];
+        if (visited.has(tri)) continue;
+        visited.add(tri);
+        remaining--;
+
+        const matched = this.trigramIndex.get(tri);
+        if (!matched) continue;
+        hits++;
+
+        if (poolOnly) {
+          for (let j = 0; j < matched.length; j++) {
+            const i = matched[j];
+            if (scores[i] > 0) scores[i]++;
+          }
+        } else {
+          for (let j = 0; j < matched.length; j++) {
+            const i = matched[j];
+            if (items[i].length >= minLen) {
+              if (scores[i] === 0) dirty.push(i);
+              scores[i]++;
             }
-          } else if (this.items[itemIndex].length >= minItemLength) {
-            scores.set(itemIndex, (scores.get(itemIndex) || 0) + 1);
           }
         }
       }
     }
 
-    return hitCount;
-  }
-
-  sortedByLength(indices, limit) {
-    const { items } = this;
-    indices.sort((a, b) => items[a].length - items[b].length);
-    if (indices.length > limit) indices.length = limit;
-    return indices.map(i => items[i]);
+    return hits;
   }
 
-  rankedResults(scores, minScore, limit) {
-    const { items } = this;
+  /**
+   * Rank candidates by prefix match, then score, then length.
+   * @private
+   * @param {number[]} indices
+   * @param {number|null} minScore - null = no score filtering (exact-match path)
+   * @param {string[]} qwords
+   * @param {Uint8Array} sep
+   * @param {number} limit
+   */
+  _rank(indices, minScore, qwords, sep, limit) {
+    const { items, _scores: scores } = this;
     const results = [];
 
-    for (const [index, score] of scores) {
-      if (score >= minScore) {
-        results.push({ index, score });
-      }
+    for (let i = 0; i < indices.length; i++) {
+      const idx = indices[i];
+      if (minScore !== null && scores[idx] < minScore) continue;
+      results.push(idx);
     }
 
-    results.sort((a, b) => {
-      if (b.score !== a.score) return b.score - a.score;
-      return items[a.index].length - items[b.index].length;
-    });
+    const pscores = new Uint8Array(items.length);
+    for (let i = 0; i < results.length; i++) {
+      pscores[results[i]] = prefixScore(items[results[i]], qwords, sep);
+    }
 
-    if (results.length > limit) results.length = limit;
+    results.sort(
+      (a, b) =>
+        pscores[b] - pscores[a] ||
+        scores[b] - scores[a] ||
+        items[a].length - items[b].length,
+    );
 
-    return results.map(r => items[r.index]);
+    if (results.length > limit) results.length = limit;
+    return results.map((i) => items[i]);
   }
 }
 
-function normalizeQuery(query) {
-  let result = '';
+// --- Helpers ---
+
+/** @param {string} query */
+function normalize(query) {
+  let out = "";
   let start = 0;
   let end = query.length;
-
   while (start < end && query.charCodeAt(start) <= 32) start++;
   while (end > start && query.charCodeAt(end - 1) <= 32) end--;
-
   for (let i = start; i < end; i++) {
-    const code = query.charCodeAt(i);
-    if (code >= 128) continue;
-    result += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : query[i];
+    const c = query.charCodeAt(i);
+    if (c >= 128) continue;
+    out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : query[i];
   }
+  return out;
+}
 
-  return result;
+/** @param {string} separators */
+function sepLookup(separators) {
+  const t = new Uint8Array(128);
+  for (let i = 0; i < separators.length; i++) {
+    const c = separators.charCodeAt(i);
+    if (c < 128) t[c] = 1;
+  }
+  return t;
 }
 
-function parseWords(text, separators, maxLength) {
+/**
+ * @param {string} text
+ * @param {Uint8Array} sep
+ * @param {number} maxLen
+ */
+function splitWords(text, sep, maxLen) {
+  /** @type {string[]} */
   const words = [];
   let start = 0;
-
   for (let i = 0; i <= text.length; i++) {
-    const isEnd = i === text.length || separators.includes(text[i]);
-
-    if (isEnd && i > start) {
-      const word = text.slice(start, i);
-      if (word.length <= maxLength && !words.includes(word)) {
-        words.push(word);
-      }
-      start = i + 1;
-    } else if (isEnd) {
-      start = i + 1;
+    if (i < text.length && !sep[text.charCodeAt(i)]) continue;
+    if (i > start) {
+      const w = text.slice(start, i);
+      if (w.length <= maxLen && !words.includes(w)) words.push(w);
     }
+    start = i + 1;
   }
-
   return words;
 }
 
+/**
+ * @param {Map<string, number[]>} index
+ * @param {string} key
+ * @param {number} value
+ */
 function addToIndex(index, key, value) {
-  const existing = index.get(key);
-  if (existing) {
-    existing.push(value);
-  } else {
-    index.set(key, [value]);
-  }
+  const arr = index.get(key);
+  if (arr) arr.push(value);
+  else index.set(key, [value]);
 }
 
-function addTrigramsToIndex(index, word, itemIndex) {
+/**
+ * @param {Map<string, number[]>} index
+ * @param {string} word
+ * @param {number} idx
+ */
+function indexTrigrams(index, word, idx) {
   if (word.length < 3) return;
-
   for (let i = 0; i <= word.length - 3; i++) {
-    const trigram = word[i] + word[i + 1] + word[i + 2];
-    const existing = index.get(trigram);
-
-    if (!existing) {
-      index.set(trigram, [itemIndex]);
-    } else if (existing[existing.length - 1] !== itemIndex) {
-      existing.push(itemIndex);
-    }
+    const tri = word[i] + word[i + 1] + word[i + 2];
+    const arr = index.get(tri);
+    if (!arr) index.set(tri, [idx]);
+    else if (arr[arr.length - 1] !== idx) arr.push(idx);
   }
 }
 
-function intersectAll(arrays) {
+/** @param {number[][]} arrays */
+function intersect(arrays) {
   if (!arrays.length) return [];
 
-  let smallestIndex = 0;
+  let si = 0;
   for (let i = 1; i < arrays.length; i++) {
-    if (arrays[i].length < arrays[smallestIndex].length) {
-      smallestIndex = i;
-    }
+    if (arrays[i].length < arrays[si].length) si = i;
   }
 
-  const result = arrays[smallestIndex].slice();
-
+  const result = arrays[si].slice();
   for (let i = 0; i < arrays.length && result.length > 0; i++) {
-    if (i === smallestIndex) continue;
-
-    let writeIndex = 0;
+    if (i === si) continue;
+    let w = 0;
     for (let j = 0; j < result.length; j++) {
-      if (binarySearch(arrays[i], result[j])) {
-        result[writeIndex++] = result[j];
-      }
+      if (bsearch(arrays[i], result[j])) result[w++] = result[j];
     }
-    result.length = writeIndex;
+    result.length = w;
   }
-
   return result;
 }
 
-function binarySearch(sortedArray, value) {
-  let low = 0;
-  let high = sortedArray.length - 1;
-
-  while (low <= high) {
-    const mid = (low + high) >> 1;
-    const midValue = sortedArray[mid];
-
-    if (midValue === value) return true;
-    if (midValue < value) low = mid + 1;
-    else high = mid - 1;
+/**
+ * @param {number[]} arr
+ * @param {number} val
+ */
+function bsearch(arr, val) {
+  let lo = 0,
+    hi = arr.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (arr[mid] === val) return true;
+    if (arr[mid] < val) lo = mid + 1;
+    else hi = mid - 1;
   }
-
   return false;
 }
 
-function pickTrigramPosition(wordLength, round) {
-  const maxPosition = wordLength - 3;
-  if (maxPosition < 0) return -1;
-
-  if (round === 0) return 0;
-  if (round === 1 && maxPosition > 0) return maxPosition;
-  if (round === 2 && maxPosition > 1) return maxPosition >> 1;
-  if (maxPosition <= 2) return -1;
-
-  const middle = maxPosition >> 1;
-  const offset = (round - 2) >> 1;
-  const position = (round & 1) ? Math.max(0, middle - offset) : middle + offset;
-
-  if (position === 0 || position >= maxPosition || position === middle) {
-    return -1;
+/**
+ * 2 = exact match, 1 = prefix match, 0 = no match
+ * @param {string} item
+ * @param {string[]} qwords
+ * @param {Uint8Array} sep
+ */
+function prefixScore(item, qwords, sep) {
+  let qi = 0,
+    pos = 0;
+  const len = item.length;
+
+  while (qi < qwords.length) {
+    while (pos < len && sep[item.charCodeAt(pos)]) pos++;
+    if (pos >= len) return 0;
+
+    const ws = pos;
+    while (pos < len && !sep[item.charCodeAt(pos)]) pos++;
+
+    const qw = qwords[qi];
+    if (pos - ws !== qw.length) return 0;
+    for (let j = 0; j < qw.length; j++) {
+      if (item.charCodeAt(ws + j) !== qw.charCodeAt(j)) return 0;
+    }
+    qi++;
   }
 
-  return position;
+  while (pos < len && sep[item.charCodeAt(pos)]) pos++;
+  return pos >= len ? 2 : 1;
+}
+
+/** @param {number} len @param {number} round */
+function trigramPosition(len, round) {
+  const max = len - 3;
+  if (max < 0) return -1;
+  if (round === 0) return 0;
+  if (round === 1 && max > 0) return max;
+  if (round === 2 && max > 1) return max >> 1;
+  if (max <= 2) return -1;
+
+  const mid = max >> 1;
+  const off = (round - 2) >> 1;
+  const pos = round & 1 ? Math.max(0, mid - off) : mid + off;
+  return pos === 0 || pos >= max || pos === mid ? -1 : pos;
 }

package/src/lib.rs

@@ -36,16 +36,16 @@ impl<'a> QuickMatch<'a> {
 
         for &item in items {
             max_query_len = max_query_len.max(item.len());
-            let mut word_count = 0;
-            for word in item.split(separators) {
-                word_count += 1;
-                if word.is_empty() {
-                    continue;
-                }
+            let item_words: Vec<&str> = item.split(separators).filter(|w| !w.is_empty()).collect();
+            max_words = max_words.max(item_words.len());
 
-                max_word_len = max_word_len.max(item.len());
+            for word in &item_words {
+                max_word_len = max_word_len.max(word.len());
 
-                word_index.entry(word.to_string()).or_default().insert(item);
+                word_index
+                    .entry(word.to_string())
+                    .or_default()
+                    .insert(item);
 
                 if word.len() >= 3 {
                     let chars = word.chars().collect::<Vec<_>>();
@@ -57,13 +57,18 @@ impl<'a> QuickMatch<'a> {
                     }
                 }
             }
-            max_words = max_words.max(word_count);
+
+            // Index adjacent word pairs as compounds (e.g. "hash"+"rate" → "hashrate")
+            for pair in item_words.windows(2) {
+                let compound = format!("{}{}", pair[0], pair[1]);
+                word_index.entry(compound).or_default().insert(item);
+            }
         }
 
         Self {
             max_query_len: max_query_len + 6,
             max_word_len: max_word_len + 4,
-            max_word_count: max_word_len + 2,
+            max_word_count: max_words + 2,
             word_index,
             trigram_index,
             config,
@@ -71,26 +76,15 @@ impl<'a> QuickMatch<'a> {
         }
     }
 
-    ///
-    /// `limit`: max number of returned matches
-    ///
-    /// `max_trigrams`: max number of processed trigrams in unknown words (0-10 recommended)
-    ///
     pub fn matches(&self, query: &str) -> Vec<&'a str> {
         self.matches_with(query, &self.config)
     }
 
-    ///
-    /// `limit`: max number of returned matches
-    ///
-    /// `max_trigrams`: max number of processed trigrams in unknown words (0-10 recommended)
-    ///
     pub fn matches_with(&self, query: &str, config: &QuickMatchConfig) -> Vec<&'a str> {
         let limit = config.limit();
         let trigram_budget = config.trigram_budget();
-        let query_len = query.len();
 
-        if query.is_empty() || query_len > self.max_query_len {
+        if query.is_empty() {
             return vec![];
         }
 
@@ -101,22 +95,30 @@ impl<'a> QuickMatch<'a> {
             .collect::<String>()
             .to_ascii_lowercase();
 
-        let words = query
-            .split(config.separators())
+        if query.is_empty() || query.len() > self.max_query_len {
+            return vec![];
+        }
+
+        let separators = config.separators();
+
+        let query_words: Vec<&str> = query
+            .split(separators)
             .filter(|w| !w.is_empty() && w.len() <= self.max_word_len)
-            .collect::<FxHashSet<_>>();
+            .collect();
+
+        let words: FxHashSet<&str> = query_words.iter().copied().collect();
 
         if words.is_empty() || words.len() > self.max_word_count {
             return vec![];
         }
 
-        let min_len = query_len.saturating_sub(3);
+        let min_len = query.len().saturating_sub(3);
 
         let mut pool: Option<FxHashSet<*const str>> = None;
         let mut unknown_words = Vec::new();
 
         let mut words_to_intersect = vec![];
-        for word in words {
+        for &word in &words {
             if let Some(items) = self.word_index.get(word) {
                 words_to_intersect.push(items)
             } else if word.len() >= 3 && unknown_words.len() < trigram_budget {
@@ -144,17 +146,23 @@ impl<'a> QuickMatch<'a> {
             let mut results: Vec<_> = pool
                 .unwrap_or_default()
                 .into_iter()
-                .map(|item| unsafe { &*item as &str })
+                .map(|item| {
+                    let s = unsafe { &*item as &str };
+                    (s, prefix_score(s, &query_words, separators))
+                })
                 .collect();
 
+            let cmp =
+                |a: &(&str, u8), b: &(&str, u8)| b.1.cmp(&a.1).then_with(|| a.0.len().cmp(&b.0.len()));
+
             if results.len() > limit {
-                results.select_nth_unstable_by_key(limit, |item| item.len());
+                results.select_nth_unstable_by(limit, cmp);
                 results.truncate(limit);
             }
 
-            results.sort_unstable_by_key(|item| item.len());
+            results.sort_unstable_by(cmp);
 
-            return results;
+            return results.into_iter().map(|(item, _)| item).collect();
         }
 
         let mut scores: FxHashMap<*const str, usize> = FxHashMap::default();
@@ -232,26 +240,52 @@ impl<'a> QuickMatch<'a> {
             }
         }
 
-        let min_score = hit_count.div_ceil(2).max(1);
+        let min_score = hit_count.div_ceil(2).max(config.min_score());
         let mut results: Vec<_> = scores
             .into_iter()
             .filter(|(_, s)| *s >= min_score)
-            .map(|(item, score)| (unsafe { &*item as &str }, score))
+            .map(|(item, score)| {
+                let s = unsafe { &*item as &str };
+                (s, score, prefix_score(s, &query_words, separators))
+            })
             .collect();
 
+        let cmp = |a: &(&str, usize, u8), b: &(&str, usize, u8)| {
+            b.2.cmp(&a.2)
+                .then_with(|| b.1.cmp(&a.1))
+                .then_with(|| a.0.len().cmp(&b.0.len()))
+        };
+
         if results.len() > limit {
-            results.select_nth_unstable_by(limit, |a, b| {
-                b.1.cmp(&a.1).then_with(|| a.0.len().cmp(&b.0.len()))
-            });
+            results.select_nth_unstable_by(limit, cmp);
             results.truncate(limit);
         }
 
-        results.sort_unstable_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.len().cmp(&b.0.len())));
+        results.sort_unstable_by(cmp);
 
         results
             .into_iter()
             .take(limit)
-            .map(|(item, _)| item)
+            .map(|(item, _, _)| item)
             .collect()
     }
 }
+
+/// Score how well an item's word sequence matches the query as a prefix.
+/// - 2: exact match (all words match, no extra words in item)
+/// - 1: prefix match (item starts with query words but has more)
+/// - 0: no prefix match
+fn prefix_score(item: &str, query_words: &[&str], separators: &[char]) -> u8 {
+    let mut item_words = item.split(separators).filter(|w| !w.is_empty());
+    for &qw in query_words {
+        match item_words.next() {
+            Some(iw) if iw == qw => continue,
+            _ => return 0,
+        }
+    }
+    if item_words.next().is_none() {
+        2
+    } else {
+        1
+    }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 quickmatch
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,26 +0,0 @@
-# quickmatch
-
-**Lightning-fast fuzzy string matching for Rust.**
-
-A high-performance string matching library optimized for interactive search experiences like autocomplete, command palettes, and search-as-you-type interfaces.
-
-[![Crates.io](https://img.shields.io/crates/v/quickmatch.svg)](https://crates.io/crates/quickmatch)
-[![Documentation](https://docs.rs/quickmatch/badge.svg)](https://docs.rs/quickmatch)
-
-## Features
-
-- **Blazing fast** - Optimized for sub-millisecond search times
-- **Hybrid matching** - Word-level matching with trigram-based fuzzy fallback
-- **Memory efficient** - Zero-copy string storage with pointer-based indexing
-- **Ranked results** - Intelligent scoring based on match quality
-- **Zero external dependencies** - Only uses `rustc-hash` for fast hashing
-
-## Installation
-
-```bash
-# rust
-cargo add quickmatch
-
-# js
-npm install quickmatch-js
-```