@quenty/fzy 1.0.1-canary.317.53a24a4.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 1.0.1-canary.317.53a24a4.0 (2022-12-29)
+
+
+### Features
+
+* Add Fzy package for fuzzy searching ([d1a4864](https://github.com/Quenty/NevermoreEngine/commit/d1a486423c84db737895c65c4b7f44005bc48e2f))

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2014-2022 Quenty
+
+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

@@ -0,0 +1,23 @@
+## Fzy
+
+<div align="center">
+  <a href="http://quenty.github.io/NevermoreEngine/">
+    <img src="https://github.com/Quenty/NevermoreEngine/actions/workflows/docs.yml/badge.svg" alt="Documentation status" />
+  </a>
+  <a href="https://discord.gg/mhtGUS8">
+    <img src="https://img.shields.io/discord/385151591524597761?color=5865F2&label=discord&logo=discord&logoColor=white" alt="Discord" />
+  </a>
+  <a href="https://github.com/Quenty/NevermoreEngine/actions">
+    <img src="https://github.com/Quenty/NevermoreEngine/actions/workflows/build.yml/badge.svg" alt="Build and release status" />
+  </a>
+</div>
+
+Lua implementation of fzy string search algorithm
+
+<div align="center"><a href="https://quenty.github.io/NevermoreEngine/api/FzyUtils">View docs →</a></div>
+
+## Installation
+
+```
+npm install @quenty/fzy --save
+```

package/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "fzy",
+  "tree": {
+    "$path": "src"
+  }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@quenty/fzy",
+  "version": "1.0.1-canary.317.53a24a4.0",
+  "description": "Lua implementation of fzy string search algorithm",
+  "keywords": [
+    "Roblox",
+    "Nevermore",
+    "Lua",
+    "Fzy",
+    "String",
+    "Fuzzy-Search",
+    "Filter"
+  ],
+  "bugs": {
+    "url": "https://github.com/Quenty/NevermoreEngine/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Quenty/NevermoreEngine.git",
+    "directory": "src/fzy/"
+  },
+  "license": "MIT",
+  "contributors": [
+    "Quenty"
+  ],
+  "dependencies": {
+    "@quenty/loader": "6.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "53a24a494885e51dba271922a1848b240872013c"
+}

package/src/Shared/Fzy.lua

@@ -0,0 +1,417 @@
+--[=[
+	The lua implementation of the fzy string matching algorithm. This algorithm
+	is optimized for matching stuff on the terminal, but should serve well as a
+	baseline search algorithm within a game too.
+
+	See:
+	* https://github.com/swarn/fzy-lua
+	* https://github.com/jhawthorn/fzy/blob/master/ALGORITHM.md
+
+	Modified from the initial code to fit this codebase. While this
+	definitely messes with some naming which may have been better, it
+	also keeps usage of this library consistent with other libraries.
+
+	Notes:
+	* A higher score is better than a lower score
+	* Scoring time is `O(n*m)` where `n` is the length of the needle
+	  and `m` is the length of the haystack.
+	* Scoring memory is also `O(n*m)`
+	* Should do quite well with small lists
+
+	TODO: Support UTF8
+
+	@class Fzy
+]=]
+
+--[[
+The MIT License (MIT)
+
+Copyright (c) 2020 Seth Warn
+
+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.
+]]
+
+local MAX_SCORE = math.huge
+local MIN_SCORE = -math.huge
+
+local Fzy = {}
+
+--[=[
+	Configuration for Fzy. See [Fzy.createConfig] for details. This affects scoring
+	and how the matching is done.
+
+	@interface FzyConfig
+	.caseSensitive boolean
+	.gapLeadingScore number
+	.gapTrailingScore number
+	.gapInnerScore number
+	.consecutiveMatchScore number
+	.slashMatchScore number
+	.wordMatchScore number
+	.capitalMatchScore number
+	.dotMatchScore number
+	.maxMatchLength number
+	@within Fzy
+]=]
+
+--[=[
+	Creates a new configuration for Fzy.
+
+	@param config table
+	@return FzyConfig
+]=]
+function Fzy.createConfig(config)
+	assert(type(config) == "table" or config == nil, "Bad config")
+
+	config = config or {}
+
+	if config.caseSensitive == nil then
+		config.caseSensitive = false
+	elseif type(config.caseSensitive) ~= "boolean" then
+		error("Bad config.caseSensitive")
+	end
+
+	-- These numbers are from the Fzy, algorithm but may be adjusted
+	config.gapLeadingScore = config.gapLeadingScore or -0.005
+	config.gapTrailingScore = config.gapTrailingScore or -0.005
+	config.gapInnerScore = config.gapInnerScore or -0.01
+	config.consecutiveMatchScore = config.consecutiveMatchScore or 1.0
+	config.slashMatchScore = config.slashMatchScore or 0.9
+	config.wordMatchScore = config.wordMatchScore or 0.8
+	config.capitalMatchScore = config.capitalMatchScore or 0.7
+	config.dotMatchScore = config.dotMatchScore or 0.6
+	config.maxMatchLength = config.maxMatchLength or 1024
+
+	return config
+end
+
+--[=[
+	Returns true if it is a config
+
+	@param config any
+	@return boolean
+]=]
+function Fzy.isFzyConfig(config)
+	return type(config) == "table"
+		and type(config.gapLeadingScore) == "number"
+		and type(config.gapTrailingScore) == "number"
+		and type(config.gapInnerScore) == "number"
+		and type(config.consecutiveMatchScore) == "number"
+		and type(config.slashMatchScore) == "number"
+		and type(config.wordMatchScore) == "number"
+		and type(config.capitalMatchScore) == "number"
+		and type(config.dotMatchScore) == "number"
+		and type(config.maxMatchLength) == "number"
+		and type(config.caseSensitive) == "boolean"
+end
+
+--[=[
+	Check if `needle` is a subsequence of the `haystack`.
+
+	Usually called before `score` or `positions`.
+
+	@param config FzyConfig
+	@param needle string
+	@param haystack string
+	@return boolean
+]=]
+function Fzy.hasMatch(config, needle: string, haystack: string)
+	if not config.caseSensitive then
+		needle = string.lower(needle)
+		haystack = string.lower(haystack)
+	end
+
+	local j = 1
+	for i = 1, string.len(needle) do
+		j = string.find(haystack, needle:sub(i, i), j, true)
+		if not j then
+			return false
+		else
+			j = j + 1
+		end
+	end
+
+	return true
+end
+
+local function is_lower(c)
+	return string.match(c, "%l")
+end
+
+local function is_upper(c)
+	return string.match(c, "%u")
+end
+
+local function precomputeBonus(config, haystack: string)
+	local matchBonus = {}
+
+	local last_char = "/"
+	for i = 1, string.len(haystack) do
+		local this_char = haystack:sub(i, i)
+		if last_char == "/" or last_char == "\\" then
+			matchBonus[i] = config.slashMatchScore
+		elseif last_char == "-" or last_char == "_" or last_char == " " then
+			matchBonus[i] = config.wordMatchScore
+		elseif last_char == "." then
+			matchBonus[i] = config.dotMatchScore
+		elseif is_lower(last_char) and is_upper(this_char) then
+			matchBonus[i] = config.capitalMatchScore
+		else
+			matchBonus[i] = 0
+		end
+
+		last_char = this_char
+	end
+
+	return matchBonus
+end
+
+local function compute(config, needle: string, haystack: string, D, M)
+	-- Note that the match bonuses must be computed before the arguments are
+	-- converted to lowercase, since there are bonuses for camelCase.
+
+	local matchBonus = precomputeBonus(config, haystack)
+	local n = string.len(needle)
+	local m = string.len(haystack)
+
+	if not config.caseSensitive then
+		needle = string.lower(needle)
+		haystack = string.lower(haystack)
+	end
+
+	-- Because lua only grants access to chars through substring extraction,
+	-- get all the characters from the haystack once now, to reuse below.
+	local haystackChars = {}
+	for i = 1, m do
+		haystackChars[i] = haystack:sub(i, i)
+	end
+
+	for i = 1, n do
+		D[i] = {}
+		M[i] = {}
+
+		local prevScore = MIN_SCORE
+		local gapScore = i == n and config.gapTrailingScore or config.gapInnerScore
+		local needle_char = needle:sub(i, i)
+
+		for j = 1, m do
+			if needle_char == haystackChars[j] then
+				local score = MIN_SCORE
+				if i == 1 then
+					score = ((j - 1) * config.gapLeadingScore) + matchBonus[j]
+				elseif j > 1 then
+					local a = M[i - 1][j - 1] + matchBonus[j]
+					local b = D[i - 1][j - 1] + config.consecutiveMatchScore
+					score = math.max(a, b)
+				end
+				D[i][j] = score
+				prevScore = math.max(score, prevScore + gapScore)
+				M[i][j] = prevScore
+			else
+				D[i][j] = MIN_SCORE
+				prevScore = prevScore + gapScore
+				M[i][j] = prevScore
+			end
+		end
+	end
+end
+
+--[=[
+	Computes whether a needle or haystack are a perfect match or not
+
+	@param config FzyConfig
+	@param needle string -- must be a subequence of `haystack`, or the result is undefined.
+	@param haystack string
+	@return boolean
+]=]
+function Fzy.isPerfectMatch(config, needle, haystack)
+	if config.caseSensitive then
+		return needle == haystack
+	else
+		return string.lower(needle) == string.lower(haystack)
+	end
+end
+
+--[=[
+	Compute a matching score.
+
+	@param config FzyConfig
+	@param needle string -- must be a subequence of `haystack`, or the result is undefined.
+	@param haystack string
+	@return number -- higher scores indicate better matches. See also [Fzy.getMinScore] and [Fzy.getMaxScore].
+]=]
+function Fzy.score(config, needle: string, haystack: string): number
+	local n = string.len(needle)
+	local m = string.len(haystack)
+
+	if n == 0 or m == 0 or m > config.maxMatchLength or n > m then
+		return MIN_SCORE
+	elseif Fzy.isPerfectMatch(config, needle, haystack) then
+		return MAX_SCORE
+	else
+		local D = {}
+		local M = {}
+		compute(config, needle, haystack, D, M)
+		return M[n][m]
+	end
+end
+
+
+--[=[
+	Compute the locations where fzy matches a string.
+
+	Determine where each character of the `needle` is matched to the `haystack`
+	in the optimal match.
+
+	@param config FzyConfig
+	@param needle string -- must be a subequence of `haystack`, or the result is undefined.
+	@param haystack string
+	@return { int } -- indices, where `indices[n]` is the location of the `n`th character of `needle` in `haystack`.
+	@return number -- the same matching score returned by `score`
+]=]
+function Fzy.positions(config, needle: string, haystack: string)
+	local n = string.len(needle)
+	local m = string.len(haystack)
+
+	if n == 0 or m == 0 or m > config.maxMatchLength or n > m then
+		return {}, MIN_SCORE
+	elseif Fzy.isPerfectMatch(config, needle, haystack) then
+		local consecutive = {}
+		for i = 1, n do
+			consecutive[i] = i
+		end
+		return consecutive, MAX_SCORE
+	end
+
+	local D = {}
+	local M = {}
+	compute(config, needle, haystack, D, M)
+
+	local positions = {}
+	local match_required = false
+	local j = m
+	for i = n, 1, -1 do
+		while j >= 1 do
+			if D[i][j] ~= MIN_SCORE and (match_required or D[i][j] == M[i][j]) then
+				match_required = (i ~= 1) and (j ~= 1) and (M[i][j] == D[i - 1][j - 1] + config.consecutiveMatchScore)
+				positions[i] = j
+				j = j - 1
+				break
+			else
+				j = j - 1
+			end
+		end
+	end
+
+	return positions, M[n][m]
+end
+
+--[=[
+	Apply [Fzy.hasMatch] and [Fzy.positions] to an array of haystacks.
+
+	Returns an array with one entry per matching line in `haystacks`,
+	each entry giving the index of the line in `haystacks` as well as
+	the equivalent to the return value of `positions` for that line.
+
+	@param config FzyConfig
+	@param needle string
+	@param haystacks { string }
+	@return {{idx, positions, score}, ...}
+]=]
+function Fzy.filter(config, needle: string, haystacks: string)
+	local result = {}
+
+	for i, line in ipairs(haystacks) do
+		if Fzy.hasMatch(config, needle, line) then
+			local p, s = Fzy.positions(config, needle, line)
+			table.insert(result, {i, p, s})
+		end
+	end
+
+	return result
+end
+
+--[=[
+	The lowest value returned by `score`.
+
+	In two special cases:
+	 - an empty `needle`, or
+	 - a `needle` or `haystack` larger than than [Fzy.getMaxLength],
+
+	the [Fzy.score] function will return this exact value, which can be used as a
+	sentinel. This is the lowest possible score.
+
+	@return number
+]=]
+function Fzy.getMinScore(): number
+	return MIN_SCORE
+end
+
+--[=[
+	The score returned for exact matches. This is the highest possible score.
+
+	@return number
+]=]
+function Fzy.getMaxScore(): number
+	return MAX_SCORE
+end
+
+--[=[
+	The maximum size for which `fzy` will evaluate scores.
+
+	@param config FzyConfig
+	@return number
+]=]
+function Fzy.getMaxLength(config): number
+	assert(Fzy.isFzyConfig(config), "Bad config")
+
+	return config.maxMatchLength
+end
+
+--[=[
+	The minimum score returned for normal matches.
+
+	For matches that don't return [Fzy.getMinScore], their score will be greater
+	than than this value.
+
+	@param config FzyConfig
+	@return number
+]=]
+function Fzy.getScoreFloor(config): number
+	assert(Fzy.isFzyConfig(config), "Bad config")
+
+	return config.maxMatchLength * config.gapInnerScore
+end
+
+--[=[
+	The maximum score for non-exact matches.
+
+	For matches that don't return [Fzy.getMaxScore], their score will be less than
+	this value.
+
+	@param config FzyConfig
+	@return number
+]=]
+function Fzy.getScoreCeiling(config): number
+	assert(Fzy.isFzyConfig(config), "Bad config")
+
+	return config.maxMatchLength * config.consecutiveMatchScore
+end
+
+return Fzy

package/src/Shared/Fzy.spec.lua

@@ -0,0 +1,253 @@
+--[[
+	Tests for fzy-lua
+
+	See:
+	https://github.com/swarn/fzy-lua
+	https://github.com/jhawthorn/fzy
+
+	@class Fzy.spec.lua
+]]
+
+--[[
+The MIT License (MIT)
+
+Copyright (c) 2020 Seth Warn
+
+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.
+]]
+
+local EPSILON = 0.000001
+
+local Fzy = require(script.Parent.Fzy)
+local MIN_SCORE = Fzy.getMinScore()
+local MAX_SCORE = Fzy.getMaxScore()
+
+local function compareTables(a, b)
+	for key, value in pairs(a) do
+		if b[key] ~= value then
+			return false
+		end
+	end
+
+	for key, value in pairs(b) do
+		if a[key] ~= value then
+			return false
+		end
+	end
+
+	return true
+end
+
+return function()
+	local config = Fzy.createConfig({
+		caseSensitive = false;
+	})
+	local caseSensitiveConfig = Fzy.createConfig({
+		caseSensitive = true;
+	})
+	local MATCH_MAX_LENGTH = Fzy.getMaxLength(config)
+
+	describe("matching", function()
+		it("exact matches", function()
+			expect(Fzy.hasMatch(config, "a", "a")).to.equal(true)
+			expect(Fzy.hasMatch(caseSensitiveConfig, "a", "a")).to.equal(true)
+			expect(Fzy.hasMatch(caseSensitiveConfig, "A", "A")).to.equal(true)
+			expect(Fzy.hasMatch(config, "a.bb", "a.bb")).to.equal(true)
+		end)
+		it("handles special characters", function()
+			expect(Fzy.hasMatch(config, "\\", "\\")).to.equal(true)
+			expect(Fzy.hasMatch(config, "/", "/")).to.equal(true)
+			expect(Fzy.hasMatch(config, "[", "[")).to.equal(true)
+			expect(Fzy.hasMatch(config, "%", "%")).to.equal(true)
+		end)
+		it("ignores case by default", function()
+			expect(Fzy.hasMatch(config, "AbB", "abb")).to.equal(true)
+			expect(Fzy.hasMatch(config, "abb", "ABB")).to.equal(true)
+		end)
+		it("is case-sensitive when requested", function()
+			expect(Fzy.hasMatch(caseSensitiveConfig, "AbB", "abb")).to.equal(false)
+			expect(Fzy.hasMatch(caseSensitiveConfig, "abb", "ABB")).to.equal(false)
+		end)
+		it("partial matches", function()
+			expect(Fzy.hasMatch(config, "a", "ab")).to.equal(true)
+			expect(Fzy.hasMatch(config, "a", "ba")).to.equal(true)
+			expect(Fzy.hasMatch(config, "aba", "baabbaab")).to.equal(true)
+		end)
+		it("with delimiters between", function()
+			expect(Fzy.hasMatch(config, "abc", "a|b|c")).to.equal(true)
+		end)
+		it("with empty query", function()
+			expect(Fzy.hasMatch(config, "", "")).to.equal(true)
+			expect(Fzy.hasMatch(config, "", "a")).to.equal(true)
+		end)
+		it("rejects non-matches", function()
+			expect(Fzy.hasMatch(config, "a", "")).to.equal(false)
+			expect(Fzy.hasMatch(config, "a", "b")).to.equal(false)
+			expect(Fzy.hasMatch(config, "aa", "a")).to.equal(false)
+			expect(Fzy.hasMatch(config, "ba", "a")).to.equal(false)
+			expect(Fzy.hasMatch(config, "ab", "a")).to.equal(false)
+		end)
+	end)
+
+	describe("scoring", function()
+		local function compare(queryStr, a, b)
+			return Fzy.score(config, queryStr, a) > Fzy.score(config, queryStr, b)
+		end
+
+		it("prefers beginnings of words", function()
+			expect(compare("amor", "app/models/order", "app/models/zrder")).to.equal(true)
+			expect(compare("amor", "app models order", "app models zrder")).to.equal(true)
+			expect(compare("amor", "appModelsOrder", "appModelsZrder")).to.equal(true)
+			expect(compare("amor", "app\\models\\order", "app\\models\\zrder")).to.equal(true)
+			expect(compare("a", ".a", "ba")).to.equal(true)
+		end)
+		it("prefers consecutive letters", function()
+			expect(compare("amo", "app/models/foo", "app/m/foo")).to.equal(true)
+			expect(compare("amo", "app/models/foo", "app/m/o")).to.equal(true)
+			expect(compare("erf", "perfect", "terrific")).to.equal(true)
+			expect(compare("abc", "*ab**c*", "*a*b*c*")).to.equal(true)
+		end)
+		it("prefers contiguous over letter following period", function()
+			expect(compare("gemfil", "Gemfile", "Gemfile.lock")).to.equal(true)
+		end)
+		it("prefers shorter matches", function()
+			expect(compare("abce", "abcdef", "abc de")).to.equal(true)
+			expect(compare("abc", "    a b c ", " a  b  c ")).to.equal(true)
+			expect(compare("abc", " a b c    ", " a  b  c ")).to.equal(true)
+			expect(compare("aa", "*a*a*", "*a**a")).to.equal(true)
+		end)
+		it("prefers shorter candidates", function()
+			expect(compare("test", "tests", "testing")).to.equal(true)
+		end)
+		it("prefers matches at the beginning", function()
+			expect(compare("ab", "abbb", "babb")).to.equal(true)
+			expect(compare("test", "testing", "/testing")).to.equal(true)
+		end)
+		it("returns the max score for exact matches", function()
+			expect(Fzy.score(config, "abc", "abc")).to.equal(MAX_SCORE)
+			expect(Fzy.score(config, "aBc", "abC")).to.equal(MAX_SCORE)
+		end)
+		it("returns the min score for empty queries", function()
+			expect(Fzy.score(config, "", "")).to.equal(MIN_SCORE)
+			expect(Fzy.score(config, "", "a")).to.equal(MIN_SCORE)
+			expect(Fzy.score(config, "", "bb")).to.equal(MIN_SCORE)
+		end)
+		it("rewards matching slashes correctly", function()
+			expect(compare("a", "*/a", "**a")).to.equal(true)
+			expect(compare("a", "*\\a", "**a")).to.equal(true)
+			expect(compare("a", "**/a", "*a")).to.equal(true)
+			expect(compare("a", "**\\a", "*a")).to.equal(true)
+			expect(compare("aa", "a/aa", "a/a")).to.equal(true)
+		end)
+		it("rewards matching camelCase correctly", function()
+			expect(compare("a", "bA", "ba")).to.equal(true)
+			expect(compare("a", "baA", "ba")).to.equal(true)
+		end)
+		it("scores in the prescribed bounds", function()
+			local aaa = string.rep("a", MATCH_MAX_LENGTH)
+			local aa = string.rep("a", MATCH_MAX_LENGTH - 1)
+			expect(Fzy.getScoreCeiling(config) > Fzy.score(config, aa, aaa)).to.equal(true)
+			local aba = "a" .. string.rep("b", MATCH_MAX_LENGTH - 2) .. "a"
+			expect(Fzy.getScoreFloor(config) < Fzy.score(config, "aa", aba)).to.equal(true)
+		end)
+		it("ignores really long strings", function()
+			local longstring = string.rep("a", MATCH_MAX_LENGTH + 1)
+			expect(Fzy.score(config, "aa", longstring)).to.equal(MIN_SCORE)
+			expect(Fzy.score(config, longstring, "aa")).to.equal(MIN_SCORE)
+			expect(Fzy.score(config, longstring, longstring)).to.equal(MIN_SCORE)
+		end)
+		it("respects the case-sensitive argument", function()
+			expect(Fzy.score(config, "aa", "bbbabab")).to.be.near(Fzy.score(caseSensitiveConfig, "AA", "aaBABAB"), EPSILON)
+			expect(Fzy.score(config, "bab", "bAacb")).to.be.near(Fzy.score(caseSensitiveConfig, "bAb", "bAaBb"), EPSILON)
+		end)
+	end)
+
+	describe("positioning", function()
+		it("favors consecutive positions", function()
+			expect(compareTables({1, 5, 6}, Fzy.positions(config, "amo", "app/models/foo"))).to.be.equal(true)
+		end)
+		it("favors word beginnings", function()
+			expect(compareTables({1, 5, 12, 13}, Fzy.positions(config, "amor", "app/models/order"))).to.be.equal(true)
+			expect(compareTables({3, 4}, Fzy.positions(config, "aa", "baAa"))).to.be.equal(true)
+			expect(compareTables({4}, Fzy.positions(config, "a", "ba.a"))).to.be.equal(true)
+		end)
+		it("works when there are no bonuses", function()
+			expect(compareTables({2, 4}, Fzy.positions(config, "as", "tags"))).to.be.equal(true)
+			expect(compareTables({3, 8}, Fzy.positions(config, "as", "examples.txt"))).to.be.equal(true)
+		end)
+		it("favors smaller groupings of positions", function()
+			expect(compareTables({3, 5, 7}, Fzy.positions(config, "abc", "a/a/b/c/c"))).to.be.equal(true)
+			expect(compareTables({3, 5, 7}, Fzy.positions(config, "abc", "a\\a\\b\\c\\c"))).to.be.equal(true)
+			expect(compareTables({4, 6, 8}, Fzy.positions(config, "abc", "*a*a*b*c*c"))).to.be.equal(true)
+			expect(compareTables({3, 5}, Fzy.positions(config, "ab", "caacbbc"))).to.be.equal(true)
+		end)
+		it("handles exact matches", function()
+			expect(compareTables({1, 2, 3}, Fzy.positions(config, "foo", "foo"))).to.be.equal(true)
+		end)
+		it("ignores empty requests", function()
+			expect(compareTables({}, Fzy.positions(config, "", ""))).to.be.equal(true)
+			expect(compareTables({}, Fzy.positions(config, "", "foo"))).to.be.equal(true)
+		end)
+		it("ignores really long strings", function()
+			local longstring = string.rep("a", MATCH_MAX_LENGTH + 1)
+			expect(Fzy.score(config, "aa", longstring)).to.equal(MIN_SCORE)
+			expect(Fzy.score(config, longstring, "aa")).to.equal(MIN_SCORE)
+			expect(Fzy.score(config, longstring, longstring)).to.equal(MIN_SCORE)
+		end)
+		it("is case-sensitive when requested", function()
+			expect(compareTables({2, 5}, Fzy.positions(caseSensitiveConfig, "AB", "aAabBb", true))).to.be.equal(true)
+		end)
+		it("returns the same score as `score()`", function()
+			local _, s = Fzy.positions(config, "ab", "aaabbb")
+			expect(Fzy.score(config, "ab", "aaabbb")).to.equal(s)
+			_, s = Fzy.positions(config, "aaa", "aaa")
+			expect(Fzy.score(config, "aaa", "aaa")).to.equal(s)
+			_, s = Fzy.positions(config, "", "aaa")
+			expect(Fzy.score(config, "", "aaa")).to.equal(s)
+		end)
+	end)
+
+	describe("filtering", function()
+		it("repeats application of hasMatch and positions", function()
+
+			-- compare the result of `filter` with repeated calls to `positions`
+			local function check_filter(needle, haystacks, case)
+				local result = Fzy.filter(config, needle, haystacks, case)
+				local r = 0
+				for i, line in ipairs(haystacks) do
+					local match = Fzy.hasMatch(config, needle, line, case)
+					if match then
+						r = r + 1
+						expect(i).to.equal(result[r][1])
+						local p, s = Fzy.positions(config, needle, line, case)
+						expect(compareTables(p, result[r][2])).to.equal(true)
+						expect(s).to.equal(result[r][3])
+					end
+				end
+				expect(#result).to.equal(r)
+			end
+
+			check_filter("a", {"a", "A", "aa", "b", ""})
+			check_filter("a", {"a", "A", "aa", "b", ""}, true)
+			check_filter("", {"a", "A", "aa", "b", ""})
+			check_filter("a", {"b"})
+			check_filter("a", {})
+		end)
+	end)
+end

package/src/node_modules.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "node_modules",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$path": { "optional": "../node_modules" }
+  }
+}

package/test/default.project.json

@@ -0,0 +1,11 @@
+{
+  "name": "FzyTest",
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "fzy": {
+        "$path": ".."
+      }
+    }
+  }
+}