feat: add launcher support and image clipboard history utility

- Integrated a new Launcher component into the shell.qml for improved application launching.
- Implemented an IPC handler to toggle the launcher visibility.
- Added a new script (cliphist-img.sh) to manage image history from the clipboard.
- Removed the outdated fuzzysort.js utility to streamline the codebase.
- Refactored the Levenshtein distance algorithm for better performance and clarity.

3 files changed, 243 insertions, 789 deletions

diff --git a/utils/cliphist-img.sh b/utils/cliphist-img.sh
new file mode 100644
index 0000000..8fe8c2c
--- /dev/null
+++ b/utils/cliphist-img.sh
@@ -0,0 +1,15 @@
+tmp_dir="/tmp/cliphist-img"
+
+mkdir -p "$tmp_dir"
+
+read -r -d '' prog <<EOF
+/^[0-9]+\s<meta http-equiv=/ { next }
+match(\$0, /^([0-9]+)\s(\[\[\s)?binary.*(jpg|jpeg|png|bmp)/, grp) {
+    path="$tmp_dir/"grp[1]"."grp[3]
+    system("echo " grp[1] "\\\\\t | cliphist decode >" path)
+    print path
+    next
+}
+EOF
+
+cliphist list | gawk "$prog"
diff --git a/utils/fuzzysort.js b/utils/fuzzysort.js
deleted file mode 100644
index 0e373ce..0000000
--- a/utils/fuzzysort.js
+++ /dev/null
@@ -1,692 +0,0 @@
-.pragma library
-
-// https://github.com/farzher/fuzzysort
-// License: MIT | Copyright (c) 2018 Stephen Kamenar
-// A copy of the license is available in the `licenses` folder of this repository
-
-var single = (search, target) => {
-	if (!search || !target) return NULL
-
-	var preparedSearch = getPreparedSearch(search)
-	if (!isPrepared(target)) target = getPrepared(target)
-
-	var searchBitflags = preparedSearch.bitflags
-	if ((searchBitflags & target._bitflags) !== searchBitflags) return NULL
-
-	return algorithm(preparedSearch, target)
-}
-
-var go = (search, targets, options) => {
-	if (!search) return options?.all ? all(targets, options) : noResults
-
-	var preparedSearch = getPreparedSearch(search)
-	var searchBitflags = preparedSearch.bitflags
-	var containsSpace = preparedSearch.containsSpace
-
-	var threshold = denormalizeScore(options?.threshold || 0)
-	var limit = options?.limit || INFINITY
-
-	var resultsLen = 0; var limitedCount = 0
-	var targetsLen = targets.length
-
-	function push_result(result) {
-		if (resultsLen < limit) { q.add(result); ++resultsLen }
-		else {
-			++limitedCount
-			if (result._score > q.peek()._score) q.replaceTop(result)
-		}
-	}
-
-	// This code is copy/pasted 3 times for performance reasons [options.key, options.keys, no keys]
-
-	// options.key
-	if (options?.key) {
-		var key = options.key
-		for (var i = 0; i < targetsLen; ++i) {
-			var obj = targets[i]
-			var target = getValue(obj, key)
-			if (!target) continue
-			if (!isPrepared(target)) target = getPrepared(target)
-
-			if ((searchBitflags & target._bitflags) !== searchBitflags) continue
-			var result = algorithm(preparedSearch, target)
-			if (result === NULL) continue
-			if (result._score < threshold) continue
-
-			result.obj = obj
-			push_result(result)
-		}
-
-		// options.keys
-	} else if (options?.keys) {
-		var keys = options.keys
-		var keysLen = keys.length
-
-		outer: for (var i = 0; i < targetsLen; ++i) {
-			var obj = targets[i]
-
-			{ // early out based on bitflags
-				var keysBitflags = 0
-				for (var keyI = 0; keyI < keysLen; ++keyI) {
-					var key = keys[keyI]
-					var target = getValue(obj, key)
-					if (!target) { tmpTargets[keyI] = noTarget; continue }
-					if (!isPrepared(target)) target = getPrepared(target)
-					tmpTargets[keyI] = target
-
-					keysBitflags |= target._bitflags
-				}
-
-				if ((searchBitflags & keysBitflags) !== searchBitflags) continue
-			}
-
-			if (containsSpace) for (let i = 0; i < preparedSearch.spaceSearches.length; i++) keysSpacesBestScores[i] = NEGATIVE_INFINITY
-
-			for (var keyI = 0; keyI < keysLen; ++keyI) {
-				target = tmpTargets[keyI]
-				if (target === noTarget) { tmpResults[keyI] = noTarget; continue }
-
-				tmpResults[keyI] = algorithm(preparedSearch, target, /*allowSpaces=*/false, /*allowPartialMatch=*/containsSpace)
-				if (tmpResults[keyI] === NULL) { tmpResults[keyI] = noTarget; continue }
-
-				// todo: this seems weird and wrong. like what if our first match wasn't good. this should just replace it instead of averaging with it
-				// if our second match isn't good we ignore it instead of averaging with it
-				if (containsSpace) for (let i = 0; i < preparedSearch.spaceSearches.length; i++) {
-					if (allowPartialMatchScores[i] > -1000) {
-						if (keysSpacesBestScores[i] > NEGATIVE_INFINITY) {
-							var tmp = (keysSpacesBestScores[i] + allowPartialMatchScores[i]) / 4/*bonus score for having multiple matches*/
-							if (tmp > keysSpacesBestScores[i]) keysSpacesBestScores[i] = tmp
-						}
-					}
-					if (allowPartialMatchScores[i] > keysSpacesBestScores[i]) keysSpacesBestScores[i] = allowPartialMatchScores[i]
-				}
-			}
-
-			if (containsSpace) {
-				for (let i = 0; i < preparedSearch.spaceSearches.length; i++) { if (keysSpacesBestScores[i] === NEGATIVE_INFINITY) continue outer }
-			} else {
-				var hasAtLeast1Match = false
-				for (let i = 0; i < keysLen; i++) { if (tmpResults[i]._score !== NEGATIVE_INFINITY) { hasAtLeast1Match = true; break } }
-				if (!hasAtLeast1Match) continue
-			}
-
-			var objResults = new KeysResult(keysLen)
-			for (let i = 0; i < keysLen; i++) { objResults[i] = tmpResults[i] }
-
-			if (containsSpace) {
-				var score = 0
-				for (let i = 0; i < preparedSearch.spaceSearches.length; i++) score += keysSpacesBestScores[i]
-			} else {
-				// todo could rewrite this scoring to be more similar to when there's spaces
-				// if we match multiple keys give us bonus points
-				var score = NEGATIVE_INFINITY
-				for (let i = 0; i < keysLen; i++) {
-					var result = objResults[i]
-					if (result._score > -1000) {
-						if (score > NEGATIVE_INFINITY) {
-							var tmp = (score + result._score) / 4/*bonus score for having multiple matches*/
-							if (tmp > score) score = tmp
-						}
-					}
-					if (result._score > score) score = result._score
-				}
-			}
-
-			objResults.obj = obj
-			objResults._score = score
-			if (options?.scoreFn) {
-				score = options.scoreFn(objResults)
-				if (!score) continue
-				score = denormalizeScore(score)
-				objResults._score = score
-			}
-
-			if (score < threshold) continue
-			push_result(objResults)
-		}
-
-		// no keys
-	} else {
-		for (var i = 0; i < targetsLen; ++i) {
-			var target = targets[i]
-			if (!target) continue
-			if (!isPrepared(target)) target = getPrepared(target)
-
-			if ((searchBitflags & target._bitflags) !== searchBitflags) continue
-			var result = algorithm(preparedSearch, target)
-			if (result === NULL) continue
-			if (result._score < threshold) continue
-
-			push_result(result)
-		}
-	}
-
-	if (resultsLen === 0) return noResults
-	var results = new Array(resultsLen)
-	for (var i = resultsLen - 1; i >= 0; --i) results[i] = q.poll()
-	results.total = resultsLen + limitedCount
-	return results
-}
-
-
-// this is written as 1 function instead of 2 for minification. perf seems fine ...
-// except when minified. the perf is very slow
-var highlight = (result, open = '<b>', close = '</b>') => {
-	var callback = typeof open === 'function' ? open : undefined
-
-	var target = result.target
-	var targetLen = target.length
-	var indexes = result.indexes
-	var highlighted = ''
-	var matchI = 0
-	var indexesI = 0
-	var opened = false
-	var parts = []
-
-	for (var i = 0; i < targetLen; ++i) {
-		var char = target[i]
-		if (indexes[indexesI] === i) {
-			++indexesI
-			if (!opened) {
-				opened = true
-				if (callback) {
-					parts.push(highlighted); highlighted = ''
-				} else {
-					highlighted += open
-				}
-			}
-
-			if (indexesI === indexes.length) {
-				if (callback) {
-					highlighted += char
-					parts.push(callback(highlighted, matchI++)); highlighted = ''
-					parts.push(target.substr(i + 1))
-				} else {
-					highlighted += char + close + target.substr(i + 1)
-				}
-				break
-			}
-		} else {
-			if (opened) {
-				opened = false
-				if (callback) {
-					parts.push(callback(highlighted, matchI++)); highlighted = ''
-				} else {
-					highlighted += close
-				}
-			}
-		}
-		highlighted += char
-	}
-
-	return callback ? parts : highlighted
-}
-
-
-var prepare = (target) => {
-	if (typeof target === 'number') target = '' + target
-	else if (typeof target !== 'string') target = ''
-	var info = prepareLowerInfo(target)
-	return new_result(target, { _targetLower: info._lower, _targetLowerCodes: info.lowerCodes, _bitflags: info.bitflags })
-}
-
-var cleanup = () => { preparedCache.clear(); preparedSearchCache.clear() }
-
-
-// Below this point is only internal code
-// Below this point is only internal code
-// Below this point is only internal code
-// Below this point is only internal code
-
-
-class Result {
-	get ['indexes']() { return this._indexes.slice(0, this._indexes.len).sort((a, b) => a - b) }
-	set ['indexes'](indexes) { return this._indexes = indexes }
-	['highlight'](open, close) { return highlight(this, open, close) }
-	get ['score']() { return normalizeScore(this._score) }
-	set ['score'](score) { this._score = denormalizeScore(score) }
-}
-
-class KeysResult extends Array {
-	get ['score']() { return normalizeScore(this._score) }
-	set ['score'](score) { this._score = denormalizeScore(score) }
-}
-
-var new_result = (target, options) => {
-	const result = new Result()
-	result['target'] = target
-	result['obj'] = options.obj ?? NULL
-	result._score = options._score ?? NEGATIVE_INFINITY
-	result._indexes = options._indexes ?? []
-	result._targetLower = options._targetLower ?? ''
-	result._targetLowerCodes = options._targetLowerCodes ?? NULL
-	result._nextBeginningIndexes = options._nextBeginningIndexes ?? NULL
-	result._bitflags = options._bitflags ?? 0
-	return result
-}
-
-
-var normalizeScore = score => {
-	if (score === NEGATIVE_INFINITY) return 0
-	if (score > 1) return score
-	return Math.E ** (((-score + 1) ** .04307 - 1) * -2)
-}
-var denormalizeScore = normalizedScore => {
-	if (normalizedScore === 0) return NEGATIVE_INFINITY
-	if (normalizedScore > 1) return normalizedScore
-	return 1 - Math.pow((Math.log(normalizedScore) / -2 + 1), 1 / 0.04307)
-}
-
-
-var prepareSearch = (search) => {
-	if (typeof search === 'number') search = '' + search
-	else if (typeof search !== 'string') search = ''
-	search = search.trim()
-	var info = prepareLowerInfo(search)
-
-	var spaceSearches = []
-	if (info.containsSpace) {
-		var searches = search.split(/\s+/)
-		searches = [...new Set(searches)] // distinct
-		for (var i = 0; i < searches.length; i++) {
-			if (searches[i] === '') continue
-			var _info = prepareLowerInfo(searches[i])
-			spaceSearches.push({ lowerCodes: _info.lowerCodes, _lower: searches[i].toLowerCase(), containsSpace: false })
-		}
-	}
-
-	return { lowerCodes: info.lowerCodes, _lower: info._lower, containsSpace: info.containsSpace, bitflags: info.bitflags, spaceSearches: spaceSearches }
-}
-
-
-
-var getPrepared = (target) => {
-	if (target.length > 999) return prepare(target) // don't cache huge targets
-	var targetPrepared = preparedCache.get(target)
-	if (targetPrepared !== undefined) return targetPrepared
-	targetPrepared = prepare(target)
-	preparedCache.set(target, targetPrepared)
-	return targetPrepared
-}
-var getPreparedSearch = (search) => {
-	if (search.length > 999) return prepareSearch(search) // don't cache huge searches
-	var searchPrepared = preparedSearchCache.get(search)
-	if (searchPrepared !== undefined) return searchPrepared
-	searchPrepared = prepareSearch(search)
-	preparedSearchCache.set(search, searchPrepared)
-	return searchPrepared
-}
-
-
-var all = (targets, options) => {
-	var results = []; results.total = targets.length // this total can be wrong if some targets are skipped
-
-	var limit = options?.limit || INFINITY
-
-	if (options?.key) {
-		for (var i = 0; i < targets.length; i++) {
-			var obj = targets[i]
-			var target = getValue(obj, options.key)
-			if (target == NULL) continue
-			if (!isPrepared(target)) target = getPrepared(target)
-			var result = new_result(target.target, { _score: target._score, obj: obj })
-			results.push(result); if (results.length >= limit) return results
-		}
-	} else if (options?.keys) {
-		for (var i = 0; i < targets.length; i++) {
-			var obj = targets[i]
-			var objResults = new KeysResult(options.keys.length)
-			for (var keyI = options.keys.length - 1; keyI >= 0; --keyI) {
-				var target = getValue(obj, options.keys[keyI])
-				if (!target) { objResults[keyI] = noTarget; continue }
-				if (!isPrepared(target)) target = getPrepared(target)
-				target._score = NEGATIVE_INFINITY
-				target._indexes.len = 0
-				objResults[keyI] = target
-			}
-			objResults.obj = obj
-			objResults._score = NEGATIVE_INFINITY
-			results.push(objResults); if (results.length >= limit) return results
-		}
-	} else {
-		for (var i = 0; i < targets.length; i++) {
-			var target = targets[i]
-			if (target == NULL) continue
-			if (!isPrepared(target)) target = getPrepared(target)
-			target._score = NEGATIVE_INFINITY
-			target._indexes.len = 0
-			results.push(target); if (results.length >= limit) return results
-		}
-	}
-
-	return results
-}
-
-
-var algorithm = (preparedSearch, prepared, allowSpaces = false, allowPartialMatch = false) => {
-	if (allowSpaces === false && preparedSearch.containsSpace) return algorithmSpaces(preparedSearch, prepared, allowPartialMatch)
-
-	var searchLower = preparedSearch._lower
-	var searchLowerCodes = preparedSearch.lowerCodes
-	var searchLowerCode = searchLowerCodes[0]
-	var targetLowerCodes = prepared._targetLowerCodes
-	var searchLen = searchLowerCodes.length
-	var targetLen = targetLowerCodes.length
-	var searchI = 0 // where we at
-	var targetI = 0 // where you at
-	var matchesSimpleLen = 0
-
-	// very basic fuzzy match; to remove non-matching targets ASAP!
-	// walk through target. find sequential matches.
-	// if all chars aren't found then exit
-	for (; ;) {
-		var isMatch = searchLowerCode === targetLowerCodes[targetI]
-		if (isMatch) {
-			matchesSimple[matchesSimpleLen++] = targetI
-			++searchI; if (searchI === searchLen) break
-			searchLowerCode = searchLowerCodes[searchI]
-		}
-		++targetI; if (targetI >= targetLen) return NULL // Failed to find searchI
-	}
-
-	var searchI = 0
-	var successStrict = false
-	var matchesStrictLen = 0
-
-	var nextBeginningIndexes = prepared._nextBeginningIndexes
-	if (nextBeginningIndexes === NULL) nextBeginningIndexes = prepared._nextBeginningIndexes = prepareNextBeginningIndexes(prepared.target)
-	targetI = matchesSimple[0] === 0 ? 0 : nextBeginningIndexes[matchesSimple[0] - 1]
-
-	// Our target string successfully matched all characters in sequence!
-	// Let's try a more advanced and strict test to improve the score
-	// only count it as a match if it's consecutive or a beginning character!
-	var backtrackCount = 0
-	if (targetI !== targetLen) for (; ;) {
-		if (targetI >= targetLen) {
-			// We failed to find a good spot for this search char, go back to the previous search char and force it forward
-			if (searchI <= 0) break // We failed to push chars forward for a better match
-
-			++backtrackCount; if (backtrackCount > 200) break // exponential backtracking is taking too long, just give up and return a bad match
-
-			--searchI
-			var lastMatch = matchesStrict[--matchesStrictLen]
-			targetI = nextBeginningIndexes[lastMatch]
-
-		} else {
-			var isMatch = searchLowerCodes[searchI] === targetLowerCodes[targetI]
-			if (isMatch) {
-				matchesStrict[matchesStrictLen++] = targetI
-				++searchI; if (searchI === searchLen) { successStrict = true; break }
-				++targetI
-			} else {
-				targetI = nextBeginningIndexes[targetI]
-			}
-		}
-	}
-
-	// check if it's a substring match
-	var substringIndex = searchLen <= 1 ? -1 : prepared._targetLower.indexOf(searchLower, matchesSimple[0]) // perf: this is slow
-	var isSubstring = !!~substringIndex
-	var isSubstringBeginning = !isSubstring ? false : substringIndex === 0 || prepared._nextBeginningIndexes[substringIndex - 1] === substringIndex
-
-	// if it's a substring match but not at a beginning index, let's try to find a substring starting at a beginning index for a better score
-	if (isSubstring && !isSubstringBeginning) {
-		for (var i = 0; i < nextBeginningIndexes.length; i = nextBeginningIndexes[i]) {
-			if (i <= substringIndex) continue
-
-			for (var s = 0; s < searchLen; s++) if (searchLowerCodes[s] !== prepared._targetLowerCodes[i + s]) break
-			if (s === searchLen) { substringIndex = i; isSubstringBeginning = true; break }
-		}
-	}
-
-	// tally up the score & keep track of matches for highlighting later
-	// if it's a simple match, we'll switch to a substring match if a substring exists
-	// if it's a strict match, we'll switch to a substring match only if that's a better score
-
-	var calculateScore = matches => {
-		var score = 0
-
-		var extraMatchGroupCount = 0
-		for (var i = 1; i < searchLen; ++i) {
-			if (matches[i] - matches[i - 1] !== 1) { score -= matches[i]; ++extraMatchGroupCount }
-		}
-		var unmatchedDistance = matches[searchLen - 1] - matches[0] - (searchLen - 1)
-
-		score -= (12 + unmatchedDistance) * extraMatchGroupCount // penality for more groups
-
-		if (matches[0] !== 0) score -= matches[0] * matches[0] * .2 // penality for not starting near the beginning
-
-		if (!successStrict) {
-			score *= 1000
-		} else {
-			// successStrict on a target with too many beginning indexes loses points for being a bad target
-			var uniqueBeginningIndexes = 1
-			for (var i = nextBeginningIndexes[0]; i < targetLen; i = nextBeginningIndexes[i]) ++uniqueBeginningIndexes
-
-			if (uniqueBeginningIndexes > 24) score *= (uniqueBeginningIndexes - 24) * 10 // quite arbitrary numbers here ...
-		}
-
-		score -= (targetLen - searchLen) / 2 // penality for longer targets
-
-		if (isSubstring) score /= 1 + searchLen * searchLen * 1 // bonus for being a full substring
-		if (isSubstringBeginning) score /= 1 + searchLen * searchLen * 1 // bonus for substring starting on a beginningIndex
-
-		score -= (targetLen - searchLen) / 2 // penality for longer targets
-
-		return score
-	}
-
-	if (!successStrict) {
-		if (isSubstring) for (var i = 0; i < searchLen; ++i) matchesSimple[i] = substringIndex + i // at this point it's safe to overwrite matchehsSimple with substr matches
-		var matchesBest = matchesSimple
-		var score = calculateScore(matchesBest)
-	} else {
-		if (isSubstringBeginning) {
-			for (var i = 0; i < searchLen; ++i) matchesSimple[i] = substringIndex + i // at this point it's safe to overwrite matchehsSimple with substr matches
-			var matchesBest = matchesSimple
-			var score = calculateScore(matchesSimple)
-		} else {
-			var matchesBest = matchesStrict
-			var score = calculateScore(matchesStrict)
-		}
-	}
-
-	prepared._score = score
-
-	for (var i = 0; i < searchLen; ++i) prepared._indexes[i] = matchesBest[i]
-	prepared._indexes.len = searchLen
-
-	const result = new Result()
-	result.target = prepared.target
-	result._score = prepared._score
-	result._indexes = prepared._indexes
-	return result
-}
-var algorithmSpaces = (preparedSearch, target, allowPartialMatch) => {
-	var seen_indexes = new Set()
-	var score = 0
-	var result = NULL
-
-	var first_seen_index_last_search = 0
-	var searches = preparedSearch.spaceSearches
-	var searchesLen = searches.length
-	var changeslen = 0
-
-	// Return _nextBeginningIndexes back to its normal state
-	var resetNextBeginningIndexes = () => {
-		for (let i = changeslen - 1; i >= 0; i--) target._nextBeginningIndexes[nextBeginningIndexesChanges[i * 2 + 0]] = nextBeginningIndexesChanges[i * 2 + 1]
-	}
-
-	var hasAtLeast1Match = false
-	for (var i = 0; i < searchesLen; ++i) {
-		allowPartialMatchScores[i] = NEGATIVE_INFINITY
-		var search = searches[i]
-
-		result = algorithm(search, target)
-		if (allowPartialMatch) {
-			if (result === NULL) continue
-			hasAtLeast1Match = true
-		} else {
-			if (result === NULL) { resetNextBeginningIndexes(); return NULL }
-		}
-
-		// if not the last search, we need to mutate _nextBeginningIndexes for the next search
-		var isTheLastSearch = i === searchesLen - 1
-		if (!isTheLastSearch) {
-			var indexes = result._indexes
-
-			var indexesIsConsecutiveSubstring = true
-			for (let i = 0; i < indexes.len - 1; i++) {
-				if (indexes[i + 1] - indexes[i] !== 1) {
-					indexesIsConsecutiveSubstring = false; break;
-				}
-			}
-
-			if (indexesIsConsecutiveSubstring) {
-				var newBeginningIndex = indexes[indexes.len - 1] + 1
-				var toReplace = target._nextBeginningIndexes[newBeginningIndex - 1]
-				for (let i = newBeginningIndex - 1; i >= 0; i--) {
-					if (toReplace !== target._nextBeginningIndexes[i]) break
-					target._nextBeginningIndexes[i] = newBeginningIndex
-					nextBeginningIndexesChanges[changeslen * 2 + 0] = i
-					nextBeginningIndexesChanges[changeslen * 2 + 1] = toReplace
-					changeslen++
-				}
-			}
-		}
-
-		score += result._score / searchesLen
-		allowPartialMatchScores[i] = result._score / searchesLen
-
-		// dock points based on order otherwise "c man" returns Manifest.cpp instead of CheatManager.h
-		if (result._indexes[0] < first_seen_index_last_search) {
-			score -= (first_seen_index_last_search - result._indexes[0]) * 2
-		}
-		first_seen_index_last_search = result._indexes[0]
-
-		for (var j = 0; j < result._indexes.len; ++j) seen_indexes.add(result._indexes[j])
-	}
-
-	if (allowPartialMatch && !hasAtLeast1Match) return NULL
-
-	resetNextBeginningIndexes()
-
-	// allows a search with spaces that's an exact substring to score well
-	var allowSpacesResult = algorithm(preparedSearch, target, /*allowSpaces=*/true)
-	if (allowSpacesResult !== NULL && allowSpacesResult._score > score) {
-		if (allowPartialMatch) {
-			for (var i = 0; i < searchesLen; ++i) {
-				allowPartialMatchScores[i] = allowSpacesResult._score / searchesLen
-			}
-		}
-		return allowSpacesResult
-	}
-
-	if (allowPartialMatch) result = target
-	result._score = score
-
-	var i = 0
-	for (let index of seen_indexes) result._indexes[i++] = index
-	result._indexes.len = i
-
-	return result
-}
-
-// we use this instead of just .normalize('NFD').replace(/[\u0300-\u036f]/g, '') because that screws with japanese characters
-var remove_accents = (str) => str.replace(/\p{Script=Latin}+/gu, match => match.normalize('NFD')).replace(/[\u0300-\u036f]/g, '')
-
-var prepareLowerInfo = (str) => {
-	str = remove_accents(str)
-	var strLen = str.length
-	var lower = str.toLowerCase()
-	var lowerCodes = [] // new Array(strLen)    sparse array is too slow
-	var bitflags = 0
-	var containsSpace = false // space isn't stored in bitflags because of how searching with a space works
-
-	for (var i = 0; i < strLen; ++i) {
-		var lowerCode = lowerCodes[i] = lower.charCodeAt(i)
-
-		if (lowerCode === 32) {
-			containsSpace = true
-			continue // it's important that we don't set any bitflags for space
-		}
-
-		var bit = lowerCode >= 97 && lowerCode <= 122 ? lowerCode - 97 // alphabet
-			: lowerCode >= 48 && lowerCode <= 57 ? 26           // numbers
-				// 3 bits available
-				: lowerCode <= 127 ? 30           // other ascii
-					: 31           // other utf8
-		bitflags |= 1 << bit
-	}
-
-	return { lowerCodes: lowerCodes, bitflags: bitflags, containsSpace: containsSpace, _lower: lower }
-}
-var prepareBeginningIndexes = (target) => {
-	var targetLen = target.length
-	var beginningIndexes = []; var beginningIndexesLen = 0
-	var wasUpper = false
-	var wasAlphanum = false
-	for (var i = 0; i < targetLen; ++i) {
-		var targetCode = target.charCodeAt(i)
-		var isUpper = targetCode >= 65 && targetCode <= 90
-		var isAlphanum = isUpper || targetCode >= 97 && targetCode <= 122 || targetCode >= 48 && targetCode <= 57
-		var isBeginning = isUpper && !wasUpper || !wasAlphanum || !isAlphanum
-		wasUpper = isUpper
-		wasAlphanum = isAlphanum
-		if (isBeginning) beginningIndexes[beginningIndexesLen++] = i
-	}
-	return beginningIndexes
-}
-var prepareNextBeginningIndexes = (target) => {
-	target = remove_accents(target)
-	var targetLen = target.length
-	var beginningIndexes = prepareBeginningIndexes(target)
-	var nextBeginningIndexes = [] // new Array(targetLen)     sparse array is too slow
-	var lastIsBeginning = beginningIndexes[0]
-	var lastIsBeginningI = 0
-	for (var i = 0; i < targetLen; ++i) {
-		if (lastIsBeginning > i) {
-			nextBeginningIndexes[i] = lastIsBeginning
-		} else {
-			lastIsBeginning = beginningIndexes[++lastIsBeginningI]
-			nextBeginningIndexes[i] = lastIsBeginning === undefined ? targetLen : lastIsBeginning
-		}
-	}
-	return nextBeginningIndexes
-}
-
-var preparedCache = new Map()
-var preparedSearchCache = new Map()
-
-// the theory behind these being globals is to reduce garbage collection by not making new arrays
-var matchesSimple = []; var matchesStrict = []
-var nextBeginningIndexesChanges = [] // allows straw berry to match strawberry well, by modifying the end of a substring to be considered a beginning index for the rest of the search
-var keysSpacesBestScores = []; var allowPartialMatchScores = []
-var tmpTargets = []; var tmpResults = []
-
-// prop = 'key'                  2.5ms optimized for this case, seems to be about as fast as direct obj[prop]
-// prop = 'key1.key2'            10ms
-// prop = ['key1', 'key2']       27ms
-// prop = obj => obj.tags.join() ??ms
-var getValue = (obj, prop) => {
-	var tmp = obj[prop]; if (tmp !== undefined) return tmp
-	if (typeof prop === 'function') return prop(obj) // this should run first. but that makes string props slower
-	var segs = prop
-	if (!Array.isArray(prop)) segs = prop.split('.')
-	var len = segs.length
-	var i = -1
-	while (obj && (++i < len)) obj = obj[segs[i]]
-	return obj
-}
-
-var isPrepared = (x) => { return typeof x === 'object' && typeof x._bitflags === 'number' }
-var INFINITY = Infinity; var NEGATIVE_INFINITY = -INFINITY
-var noResults = []; noResults.total = 0
-var NULL = null
-
-var noTarget = prepare('')
-
-// Hacked version of https://github.com/lemire/FastPriorityQueue.js
-var fastpriorityqueue = r => { var e = [], o = 0, a = {}, v = r => { for (var a = 0, v = e[a], c = 1; c < o;) { var s = c + 1; a = c, s < o && e[s]._score < e[c]._score && (a = s), e[a - 1 >> 1] = e[a], c = 1 + (a << 1) } for (var f = a - 1 >> 1; a > 0 && v._score < e[f]._score; f = (a = f) - 1 >> 1)e[a] = e[f]; e[a] = v }; return a.add = (r => { var a = o; e[o++] = r; for (var v = a - 1 >> 1; a > 0 && r._score < e[v]._score; v = (a = v) - 1 >> 1)e[a] = e[v]; e[a] = r }), a.poll = (r => { if (0 !== o) { var a = e[0]; return e[0] = e[--o], v(), a } }), a.peek = (r => { if (0 !== o) return e[0] }), a.replaceTop = (r => { e[0] = r, v() }), a }
-var q = fastpriorityqueue() // reuse this
-
diff --git a/utils/levendist.js b/utils/levendist.js
index ed8a5d8..6565e0a 100644
--- a/utils/levendist.js
+++ b/utils/levendist.js
@@ -1,142 +1,273 @@
-// Original code from https://github.com/koeqaife/hyprland-material-you
-// Original code license: GPLv3
-// Translated to Js from Cython with an LLM and reviewed
+var peq = new Uint32Array(0x10000);
 
-function min3(a, b, c) {
-	return a < b && a < c ? a : b < c ? b : c;
-}
+var myers_32 = function(a, b) {
 
-function max3(a, b, c) {
-	return a > b && a > c ? a : b > c ? b : c;
-}
+	var n = a.length;
 
-function min2(a, b) {
-	return a < b ? a : b;
-}
+	var m = b.length;
 
-function max2(a, b) {
-	return a > b ? a : b;
-}
+	var lst = 1 << (n - 1);
 
-function levenshteinDistance(s1, s2) {
-	let len1 = s1.length;
-	let len2 = s2.length;
+	var pv = -1;
 
-	if (len1 === 0) return len2;
-	if (len2 === 0) return len1;
+	var mv = 0;
 
-	if (len2 > len1) {
-		[s1, s2] = [s2, s1];
-		[len1, len2] = [len2, len1];
-	}
+	var sc = n;
+
+	var i = n;
 
-	let prev = new Array(len2 + 1);
-	let curr = new Array(len2 + 1);
+	while (i--) {
+
+		peq[a.charCodeAt(i)] |= 1 << i;
 
-	for (let j = 0; j <= len2; j++) {
-		prev[j] = j;
 	}
 
-	for (let i = 1; i <= len1; i++) {
-		curr[0] = i;
-		for (let j = 1; j <= len2; j++) {
-			let cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
-			curr[j] = min3(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+	for (i = 0; i < m; i++) {
+
+		var eq = peq[b.charCodeAt(i)];
+
+		var xv = eq | mv;
+
+		eq |= ((eq & pv) + pv) ^ pv;
+
+		mv |= ~(eq | pv);
+
+		pv &= eq;
+
+		if (mv & lst) {
+
+			sc++;
+
+		}
+
+		if (pv & lst) {
+
+			sc--;
+
 		}
-		[prev, curr] = [curr, prev];
+
+		mv = (mv << 1) | 1;
+
+		pv = (pv << 1) | ~(xv | mv);
+
+		mv &= xv;
+
 	}
 
-	return prev[len2];
-}
+	i = n;
 
-function partialRatio(shortS, longS) {
-	let lenS = shortS.length;
-	let lenL = longS.length;
-	let best = 0.0;
+	while (i--) {
 
-	if (lenS === 0) return 1.0;
+		peq[a.charCodeAt(i)] = 0;
 
-	for (let i = 0; i <= lenL - lenS; i++) {
-		let sub = longS.slice(i, i + lenS);
-		let dist = levenshteinDistance(shortS, sub);
-		let score = 1.0 - (dist / lenS);
-		if (score > best) best = score;
 	}
 
-	return best;
-}
+	return sc;
+
+};
+
+var myers_x = function(b, a) {
+
+	var n = a.length;
 
-function computeScore(s1, s2) {
-	if (s1 === s2) return 1.0;
+	var m = b.length;
 
-	let dist = levenshteinDistance(s1, s2);
-	let maxLen = max2(s1.length, s2.length);
-	if (maxLen === 0) return 1.0;
+	var mhc = [];
 
-	let full = 1.0 - (dist / maxLen);
-	let part = s1.length < s2.length ? partialRatio(s1, s2) : partialRatio(s2, s1);
+	var phc = [];
 
-	let score = 0.85 * full + 0.15 * part;
+	var hsize = Math.ceil(n / 32);
+
+	var vsize = Math.ceil(m / 32);
+
+	for (var i = 0; i < hsize; i++) {
+
+		phc[i] = -1;
+
+		mhc[i] = 0;
 
-	if (s1 && s2 && s1[0] !== s2[0]) {
-		score -= 0.05;
 	}
 
-	let lenDiff = Math.abs(s1.length - s2.length);
-	if (lenDiff >= 3) {
-		score -= 0.05 * lenDiff / maxLen;
+	var j = 0;
+
+	for (; j < vsize - 1; j++) {
+
+		var mv_1 = 0;
+
+		var pv_1 = -1;
+
+		var start_1 = j * 32;
+
+		var vlen_1 = Math.min(32, m) + start_1;
+
+		for (var k = start_1; k < vlen_1; k++) {
+
+			peq[b.charCodeAt(k)] |= 1 << k;
+
+		}
+
+		for (var i = 0; i < n; i++) {
+
+			var eq = peq[a.charCodeAt(i)];
+
+			var pb = (phc[(i / 32) | 0] >>> i) & 1;
+
+			var mb = (mhc[(i / 32) | 0] >>> i) & 1;
+
+			var xv = eq | mv_1;
+
+			var xh = ((((eq | mb) & pv_1) + pv_1) ^ pv_1) | eq | mb;
+
+			var ph = mv_1 | ~(xh | pv_1);
+
+			var mh = pv_1 & xh;
+
+			if ((ph >>> 31) ^ pb) {
+
+				phc[(i / 32) | 0] ^= 1 << i;
+
+			}
+
+			if ((mh >>> 31) ^ mb) {
+
+				mhc[(i / 32) | 0] ^= 1 << i;
+
+			}
+
+			ph = (ph << 1) | pb;
+
+			mh = (mh << 1) | mb;
+
+			pv_1 = mh | ~(xv | ph);
+
+			mv_1 = ph & xv;
+
+		}
+
+		for (var k = start_1; k < vlen_1; k++) {
+
+			peq[b.charCodeAt(k)] = 0;
+
+		}
+
+	}
+
+	var mv = 0;
+
+	var pv = -1;
+
+	var start = j * 32;
+
+	var vlen = Math.min(32, m - start) + start;
+
+	for (var k = start; k < vlen; k++) {
+
+		peq[b.charCodeAt(k)] |= 1 << k;
+
 	}
 
-	let commonPrefixLen = 0;
-	let minLen = min2(s1.length, s2.length);
-	for (let i = 0; i < minLen; i++) {
-		if (s1[i] === s2[i]) {
-			commonPrefixLen++;
-		} else {
-			break;
+	var score = m;
+
+	for (var i = 0; i < n; i++) {
+
+		var eq = peq[a.charCodeAt(i)];
+
+		var pb = (phc[(i / 32) | 0] >>> i) & 1;
+
+		var mb = (mhc[(i / 32) | 0] >>> i) & 1;
+
+		var xv = eq | mv;
+
+		var xh = ((((eq | mb) & pv) + pv) ^ pv) | eq | mb;
+
+		var ph = mv | ~(xh | pv);
+
+		var mh = pv & xh;
+
+		score += (ph >>> (m - 1)) & 1;
+
+		score -= (mh >>> (m - 1)) & 1;
+
+		if ((ph >>> 31) ^ pb) {
+
+			phc[(i / 32) | 0] ^= 1 << i;
+
+		}
+
+		if ((mh >>> 31) ^ mb) {
+
+			mhc[(i / 32) | 0] ^= 1 << i;
+
 		}
+
+		ph = (ph << 1) | pb;
+
+		mh = (mh << 1) | mb;
+
+		pv = mh | ~(xv | ph);
+
+		mv = ph & xv;
+
 	}
-	score += 0.02 * commonPrefixLen;
 
-	if (s1.includes(s2) || s2.includes(s1)) {
-		score += 0.06;
+	for (var k = start; k < vlen; k++) {
+
+		peq[b.charCodeAt(k)] = 0;
+
 	}
 
-	return Math.max(0.0, Math.min(1.0, score));
-}
+	return score;
 
-function computeTextMatchScore(s1, s2) {
-	if (s1 === s2) return 1.0;
+};
 
-	let dist = levenshteinDistance(s1, s2);
-	let maxLen = max2(s1.length, s2.length);
-	if (maxLen === 0) return 1.0;
+var distance = function(a, b) {
 
-	let full = 1.0 - (dist / maxLen);
-	let part = s1.length < s2.length ? partialRatio(s1, s2) : partialRatio(s2, s1);
+	if (a.length < b.length) {
 
-	let score = 0.4 * full + 0.6 * part;
+		var tmp = b;
+
+		b = a;
+
+		a = tmp;
 
-	let lenDiff = Math.abs(s1.length - s2.length);
-	if (lenDiff >= 10) {
-		score -= 0.02 * lenDiff / maxLen;
 	}
 
-	let commonPrefixLen = 0;
-	let minLen = min2(s1.length, s2.length);
-	for (let i = 0; i < minLen; i++) {
-		if (s1[i] === s2[i]) {
-			commonPrefixLen++;
-		} else {
-			break;
-		}
+	if (b.length === 0) {
+
+		return a.length;
+
+	}
+
+	if (a.length <= 32) {
+
+		return myers_32(a, b);
+
 	}
-	score += 0.01 * commonPrefixLen;
 
-	if (s1.includes(s2) || s2.includes(s1)) {
-		score += 0.2;
+	return myers_x(a, b);
+
+};
+
+var closest = function(str, arr) {
+
+	var min_distance = Infinity;
+
+	var min_index = 0;
+
+	for (var i = 0; i < arr.length; i++) {
+
+		var dist = distance(str, arr[i]);
+
+		if (dist < min_distance) {
+
+			min_distance = dist;
+
+			min_index = i;
+
+		}
+
 	}
 
-	return Math.max(0.0, Math.min(1.0, score));
-}
+	return arr[min_index];
 
+};