diff --git a/clean.go b/clean.go
index 9c5c50b..271f5ae 100644
--- a/clean.go
+++ b/clean.go
@@ -6,7 +6,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/Jguer/yay/v9/pkg/types"
+		"github.com/Jguer/yay/v9/pkg/stringset"
 )
 
 // GetPkgbuild gets the pkgbuild of the package 'pkg' trying the ABS first and then the AUR trying the ABS first and then the AUR.
@@ -109,8 +109,8 @@ func syncClean(parser *arguments) error {
 func cleanAUR(keepInstalled, keepCurrent, removeAll bool) error {
 	fmt.Println("removing AUR packages from cache...")
 
-	installedBases := make(types.StringSet)
-	inAURBases := make(types.StringSet)
+	installedBases := make(stringset.StringSet)
+	inAURBases := make(stringset.StringSet)
 
 	_, remotePackages, _, _, err := filterPackages()
 	if err != nil {
diff --git a/depCheck.go b/depCheck.go
index ad19cb5..4d30d65 100644
--- a/depCheck.go
+++ b/depCheck.go
@@ -7,10 +7,10 @@ import (
 	"sync"
 
 	alpm "github.com/Jguer/go-alpm"
-	"github.com/Jguer/yay/v9/pkg/types"
+		"github.com/Jguer/yay/v9/pkg/stringset"
 )
 
-func (dp *depPool) checkInnerConflict(name string, conflict string, conflicts types.MapStringSet) {
+func (dp *depPool) checkInnerConflict(name string, conflict string, conflicts stringset.MapStringSet) {
 	for _, pkg := range dp.Aur {
 		if pkg.Name == name {
 			continue
@@ -32,7 +32,7 @@ func (dp *depPool) checkInnerConflict(name string, conflict string, conflicts ty
 	}
 }
 
-func (dp *depPool) checkForwardConflict(name string, conflict string, conflicts types.MapStringSet) {
+func (dp *depPool) checkForwardConflict(name string, conflict string, conflicts stringset.MapStringSet) {
 	_ = dp.LocalDB.PkgCache().ForEach(func(pkg alpm.Package) error {
 		if pkg.Name() == name || dp.hasPackage(pkg.Name()) {
 			return nil
@@ -50,7 +50,7 @@ func (dp *depPool) checkForwardConflict(name string, conflict string, conflicts
 	})
 }
 
-func (dp *depPool) checkReverseConflict(name string, conflict string, conflicts types.MapStringSet) {
+func (dp *depPool) checkReverseConflict(name string, conflict string, conflicts stringset.MapStringSet) {
 	for _, pkg := range dp.Aur {
 		if pkg.Name == name {
 			continue
@@ -80,7 +80,7 @@ func (dp *depPool) checkReverseConflict(name string, conflict string, conflicts
 	}
 }
 
-func (dp *depPool) checkInnerConflicts(conflicts types.MapStringSet) {
+func (dp *depPool) checkInnerConflicts(conflicts stringset.MapStringSet) {
 	for _, pkg := range dp.Aur {
 		for _, conflict := range pkg.Conflicts {
 			dp.checkInnerConflict(pkg.Name, conflict, conflicts)
@@ -95,7 +95,7 @@ func (dp *depPool) checkInnerConflicts(conflicts types.MapStringSet) {
 	}
 }
 
-func (dp *depPool) checkForwardConflicts(conflicts types.MapStringSet) {
+func (dp *depPool) checkForwardConflicts(conflicts stringset.MapStringSet) {
 	for _, pkg := range dp.Aur {
 		for _, conflict := range pkg.Conflicts {
 			dp.checkForwardConflict(pkg.Name, conflict, conflicts)
@@ -110,7 +110,7 @@ func (dp *depPool) checkForwardConflicts(conflicts types.MapStringSet) {
 	}
 }
 
-func (dp *depPool) checkReverseConflicts(conflicts types.MapStringSet) {
+func (dp *depPool) checkReverseConflicts(conflicts stringset.MapStringSet) {
 	_ = dp.LocalDB.PkgCache().ForEach(func(pkg alpm.Package) error {
 		if dp.hasPackage(pkg.Name()) {
 			return nil
@@ -125,10 +125,10 @@ func (dp *depPool) checkReverseConflicts(conflicts types.MapStringSet) {
 	})
 }
 
-func (dp *depPool) CheckConflicts() (types.MapStringSet, error) {
+func (dp *depPool) CheckConflicts() (stringset.MapStringSet, error) {
 	var wg sync.WaitGroup
-	innerConflicts := make(types.MapStringSet)
-	conflicts := make(types.MapStringSet)
+	innerConflicts := make(stringset.MapStringSet)
+	conflicts := make(stringset.MapStringSet)
 	wg.Add(2)
 
 	fmt.Println(bold(cyan("::") + bold(" Checking for conflicts...")))
@@ -182,9 +182,9 @@ func (dp *depPool) CheckConflicts() (types.MapStringSet, error) {
 	// These are used to decide what to pass --ask to (if set) or don't pass --noconfirm to
 	// As we have no idea what the order is yet we add every inner conflict to the slice
 	for name, pkgs := range innerConflicts {
-		conflicts[name] = make(types.StringSet)
+		conflicts[name] = make(stringset.StringSet)
 		for pkg := range pkgs {
-			conflicts[pkg] = make(types.StringSet)
+			conflicts[pkg] = make(stringset.StringSet)
 		}
 	}
 
@@ -204,7 +204,7 @@ func (dp *depPool) CheckConflicts() (types.MapStringSet, error) {
 }
 
 type missing struct {
-	Good    types.StringSet
+	Good    stringset.StringSet
 	Missing map[string][][]string
 }
 
@@ -261,7 +261,7 @@ func (dp *depPool) _checkMissing(dep string, stack []string, missing *missing) {
 
 func (dp *depPool) CheckMissing() error {
 	missing := &missing{
-		make(types.StringSet),
+		make(stringset.StringSet),
 		make(map[string][][]string),
 	}
 
diff --git a/depOrder.go b/depOrder.go
index 786c386..ac089cd 100644
--- a/depOrder.go
+++ b/depOrder.go
@@ -2,7 +2,7 @@ package main
 
 import (
 	alpm "github.com/Jguer/go-alpm"
-	"github.com/Jguer/yay/v9/pkg/types"
+		"github.com/Jguer/yay/v9/pkg/stringset"
 	rpc "github.com/mikkeloscar/aur"
 )
 
@@ -27,14 +27,14 @@ func (b Base) URLPath() string {
 type depOrder struct {
 	Aur     []Base
 	Repo    []*alpm.Package
-	Runtime types.StringSet
+	Runtime stringset.StringSet
 }
 
 func makeDepOrder() *depOrder {
 	return &depOrder{
 		make([]Base, 0),
 		make([]*alpm.Package, 0),
-		make(types.StringSet),
+		make(stringset.StringSet),
 	}
 }
 
diff --git a/depPool.go b/depPool.go
index e02588e..73c39fb 100644
--- a/depPool.go
+++ b/depPool.go
@@ -6,7 +6,7 @@ import (
 	"sync"
 
 	alpm "github.com/Jguer/go-alpm"
-	"github.com/Jguer/yay/v9/pkg/types"
+		"github.com/Jguer/yay/v9/pkg/stringset"
 	rpc "github.com/mikkeloscar/aur"
 )
 
@@ -43,7 +43,7 @@ func (t target) String() string {
 
 type depPool struct {
 	Targets  []target
-	Explicit types.StringSet
+	Explicit stringset.StringSet
 	Repo     map[string]*alpm.Package
 	Aur      map[string]*rpc.Pkg
 	AurCache map[string]*rpc.Pkg
@@ -65,7 +65,7 @@ func makeDepPool() (*depPool, error) {
 
 	dp := &depPool{
 		make([]target, 0),
-		make(types.StringSet),
+		make(stringset.StringSet),
 		make(map[string]*alpm.Package),
 		make(map[string]*rpc.Pkg),
 		make(map[string]*rpc.Pkg),
@@ -83,7 +83,7 @@ func (dp *depPool) ResolveTargets(pkgs []string) error {
 	// RPC requests are slow
 	// Combine as many AUR package requests as possible into a single RPC
 	// call
-	aurTargets := make(types.StringSet)
+	aurTargets := make(stringset.StringSet)
 
 	pkgs = removeInvalidTargets(pkgs)
 
@@ -173,7 +173,7 @@ func (dp *depPool) ResolveTargets(pkgs []string) error {
 // positives.
 //
 // This method increases dependency resolve time
-func (dp *depPool) findProvides(pkgs types.StringSet) error {
+func (dp *depPool) findProvides(pkgs stringset.StringSet) error {
 	var mux sync.Mutex
 	var wg sync.WaitGroup
 
@@ -220,7 +220,7 @@ func (dp *depPool) findProvides(pkgs types.StringSet) error {
 	return nil
 }
 
-func (dp *depPool) cacheAURPackages(_pkgs types.StringSet) error {
+func (dp *depPool) cacheAURPackages(_pkgs stringset.StringSet) error {
 	pkgs := _pkgs.Copy()
 	query := make([]string, 0)
 
@@ -261,9 +261,9 @@ func (dp *depPool) cacheAURPackages(_pkgs types.StringSet) error {
 	return nil
 }
 
-func (dp *depPool) resolveAURPackages(pkgs types.StringSet, explicit bool) error {
-	newPackages := make(types.StringSet)
-	newAURPackages := make(types.StringSet)
+func (dp *depPool) resolveAURPackages(pkgs stringset.StringSet, explicit bool) error {
+	newPackages := make(stringset.StringSet)
+	newAURPackages := make(stringset.StringSet)
 
 	err := dp.cacheAURPackages(pkgs)
 	if err != nil {
@@ -387,7 +387,7 @@ func (dp *depPool) findSatisfierAur(dep string) *rpc.Pkg {
 // TODO: maybe intermix repo providers in the menu
 func (dp *depPool) findSatisfierAurCache(dep string) *rpc.Pkg {
 	depName, _, _ := splitDep(dep)
-	seen := make(types.StringSet)
+	seen := make(stringset.StringSet)
 	providers := makeProviders(depName)
 
 	if dp.LocalDB.Pkg(depName) != nil {
diff --git a/install.go b/install.go
index 18b93b6..921b6dd 100644
--- a/install.go
+++ b/install.go
@@ -12,6 +12,7 @@ import (
 	alpm "github.com/Jguer/go-alpm"
 	"github.com/Jguer/yay/v9/pkg/completion"
 	"github.com/Jguer/yay/v9/pkg/types"
+	"github.com/Jguer/yay/v9/pkg/stringset"
 	gosrc "github.com/Morganamilo/go-srcinfo"
 )
 
@@ -49,7 +50,7 @@ func asexp(parser *arguments, pkgs []string) error {
 
 // Install handles package installs
 func install(parser *arguments) (err error) {
-	var incompatible types.StringSet
+	var incompatible stringset.StringSet
 	var do *depOrder
 
 	var aurUp upSlice
@@ -87,8 +88,8 @@ func install(parser *arguments) (err error) {
 		return err
 	}
 
-	remoteNamesCache := types.SliceToStringSet(remoteNames)
-	localNamesCache := types.SliceToStringSet(localNames)
+	remoteNamesCache := stringset.SliceToStringSet(remoteNames)
+	localNamesCache := stringset.SliceToStringSet(localNames)
 
 	requestTargets := parser.copy().targets
 
@@ -140,7 +141,7 @@ func install(parser *arguments) (err error) {
 		}
 	}
 
-	targets := types.SliceToStringSet(parser.targets)
+	targets := stringset.SliceToStringSet(parser.targets)
 
 	dp, err := getDepPool(requestTargets, warnings)
 	if err != nil {
@@ -451,8 +452,8 @@ func earlyRefresh(parser *arguments) error {
 	return show(passToPacman(arguments))
 }
 
-func getIncompatible(bases []Base, srcinfos map[string]*gosrc.Srcinfo) (types.StringSet, error) {
-	incompatible := make(types.StringSet)
+func getIncompatible(bases []Base, srcinfos map[string]*gosrc.Srcinfo) (stringset.StringSet, error) {
+	incompatible := make(stringset.StringSet)
 	basesMap := make(map[string]Base)
 	alpmArch, err := alpmHandle.Arch()
 	if err != nil {
@@ -535,7 +536,7 @@ func anyExistInCache(bases []Base) bool {
 	return false
 }
 
-func pkgbuildNumberMenu(bases []Base, installed types.StringSet) bool {
+func pkgbuildNumberMenu(bases []Base, installed stringset.StringSet) bool {
 	toPrint := ""
 	askClean := false
 
@@ -568,7 +569,7 @@ func pkgbuildNumberMenu(bases []Base, installed types.StringSet) bool {
 	return askClean
 }
 
-func cleanNumberMenu(bases []Base, installed types.StringSet, hasClean bool) ([]Base, error) {
+func cleanNumberMenu(bases []Base, installed stringset.StringSet, hasClean bool) ([]Base, error) {
 	toClean := make([]Base, 0)
 
 	if !hasClean {
@@ -637,15 +638,15 @@ func cleanNumberMenu(bases []Base, installed types.StringSet, hasClean bool) ([]
 	return toClean, nil
 }
 
-func editNumberMenu(bases []Base, installed types.StringSet) ([]Base, error) {
+func editNumberMenu(bases []Base, installed stringset.StringSet) ([]Base, error) {
 	return editDiffNumberMenu(bases, installed, false)
 }
 
-func diffNumberMenu(bases []Base, installed types.StringSet) ([]Base, error) {
+func diffNumberMenu(bases []Base, installed stringset.StringSet) ([]Base, error) {
 	return editDiffNumberMenu(bases, installed, true)
 }
 
-func editDiffNumberMenu(bases []Base, installed types.StringSet, diff bool) ([]Base, error) {
+func editDiffNumberMenu(bases []Base, installed stringset.StringSet, diff bool) ([]Base, error) {
 	toEdit := make([]Base, 0)
 	var editInput string
 	var err error
@@ -715,7 +716,7 @@ func editDiffNumberMenu(bases []Base, installed types.StringSet, diff bool) ([]B
 	return toEdit, nil
 }
 
-func updatePkgbuildSeenRef(bases []Base, cloned types.StringSet) error {
+func updatePkgbuildSeenRef(bases []Base, cloned stringset.StringSet) error {
 	var errMulti types.MultiError
 	for _, base := range bases {
 		pkg := base.Pkgbase()
@@ -730,7 +731,7 @@ func updatePkgbuildSeenRef(bases []Base, cloned types.StringSet) error {
 	return errMulti.Return()
 }
 
-func showPkgbuildDiffs(bases []Base, cloned types.StringSet) error {
+func showPkgbuildDiffs(bases []Base, cloned stringset.StringSet) error {
 	var errMulti types.MultiError
 	for _, base := range bases {
 		pkg := base.Pkgbase()
@@ -840,8 +841,8 @@ func parseSrcinfoFiles(bases []Base, errIsFatal bool) (map[string]*gosrc.Srcinfo
 	return srcinfos, nil
 }
 
-func pkgbuildsToSkip(bases []Base, targets types.StringSet) types.StringSet {
-	toSkip := make(types.StringSet)
+func pkgbuildsToSkip(bases []Base, targets stringset.StringSet) stringset.StringSet {
+	toSkip := make(stringset.StringSet)
 
 	for _, base := range bases {
 		isTarget := false
@@ -879,8 +880,8 @@ func mergePkgbuilds(bases []Base) error {
 	return nil
 }
 
-func downloadPkgbuilds(bases []Base, toSkip types.StringSet, buildDir string) (types.StringSet, error) {
-	cloned := make(types.StringSet)
+func downloadPkgbuilds(bases []Base, toSkip stringset.StringSet, buildDir string) (stringset.StringSet, error) {
+	cloned := make(stringset.StringSet)
 	downloaded := 0
 	var wg sync.WaitGroup
 	var mux sync.Mutex
@@ -940,7 +941,7 @@ func downloadPkgbuilds(bases []Base, toSkip types.StringSet, buildDir string) (t
 	return cloned, errs.Return()
 }
 
-func downloadPkgbuildsSources(bases []Base, incompatible types.StringSet) (err error) {
+func downloadPkgbuildsSources(bases []Base, incompatible stringset.StringSet) (err error) {
 	for _, base := range bases {
 		pkg := base.Pkgbase()
 		dir := filepath.Join(config.BuildDir, pkg)
@@ -959,7 +960,7 @@ func downloadPkgbuildsSources(bases []Base, incompatible types.StringSet) (err e
 	return
 }
 
-func buildInstallPkgbuilds(dp *depPool, do *depOrder, srcinfos map[string]*gosrc.Srcinfo, parser *arguments, incompatible types.StringSet, conflicts types.MapStringSet) error {
+func buildInstallPkgbuilds(dp *depPool, do *depOrder, srcinfos map[string]*gosrc.Srcinfo, parser *arguments, incompatible stringset.StringSet, conflicts stringset.MapStringSet) error {
 	arguments := parser.copy()
 	arguments.clearTargets()
 	arguments.op = "U"
@@ -985,8 +986,8 @@ func buildInstallPkgbuilds(dp *depPool, do *depOrder, srcinfos map[string]*gosrc
 
 	//cache as a stringset. maybe make it return a string set in the first
 	//place
-	remoteNamesCache := types.SliceToStringSet(remoteNames)
-	localNamesCache := types.SliceToStringSet(localNames)
+	remoteNamesCache := stringset.SliceToStringSet(remoteNames)
+	localNamesCache := stringset.SliceToStringSet(localNames)
 
 	doInstall := func() error {
 		if len(arguments.targets) == 0 {
diff --git a/parser.go b/parser.go
index 3fad57c..e357fff 100644
--- a/parser.go
+++ b/parser.go
@@ -9,7 +9,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/Jguer/yay/v9/pkg/types"
+		"github.com/Jguer/yay/v9/pkg/stringset"
 	rpc "github.com/mikkeloscar/aur"
 )
 
@@ -19,7 +19,7 @@ type arguments struct {
 	op      string
 	options map[string]string
 	globals map[string]string
-	doubles types.StringSet // Tracks args passed twice such as -yy and -dd
+	doubles stringset.StringSet // Tracks args passed twice such as -yy and -dd
 	targets []string
 }
 
@@ -28,7 +28,7 @@ func makeArguments() *arguments {
 		"",
 		make(map[string]string),
 		make(map[string]string),
-		make(types.StringSet),
+		make(stringset.StringSet),
 		make([]string, 0),
 	}
 }
diff --git a/pkg/types/stringset.go b/pkg/stringset/stringset.go
similarity index 92%
rename from pkg/types/stringset.go
rename to pkg/stringset/stringset.go
index 8edf0c9..4c3eb06 100644
--- a/pkg/types/stringset.go
+++ b/pkg/stringset/stringset.go
@@ -1,4 +1,4 @@
-package types
+package stringset
 
 // StringSet is a basic set implementation for strings.
 // This is used a lot so it deserves its own type.
@@ -12,6 +12,8 @@ type StringSet map[string]struct{}
 type MapStringSet map[string]StringSet
 
 // Add adds a new value to the Map.
+// If n is already in the map, then v is appended to the StringSet under that key.
+// Otherwise a new StringSet is creayed containing v
 func (mss MapStringSet) Add(n string, v string) {
 	_, ok := mss[n]
 	if !ok {
diff --git a/pkg/types/intrange.go b/pkg/types/intrange.go
index 4e27ee0..e9c67a1 100644
--- a/pkg/types/intrange.go
+++ b/pkg/types/intrange.go
@@ -4,6 +4,8 @@ import (
 	"strconv"
 	"strings"
 	"unicode"
+	"github.com/Jguer/yay/v9/pkg/stringset"
+
 )
 
 // IntRange stores a max and min amount for range
@@ -66,11 +68,11 @@ func Max(a, b int) int {
 //intended to allow words inside of number menus. e.g. 'all' 'none' 'abort'
 //of course the implementation is up to the caller, this function mearley parses
 //the input and organizes it
-func ParseNumberMenu(input string) (IntRanges, IntRanges, StringSet, StringSet) {
+func ParseNumberMenu(input string) (IntRanges, IntRanges, stringset.StringSet, stringset.StringSet) {
 	include := make(IntRanges, 0)
 	exclude := make(IntRanges, 0)
-	otherInclude := make(StringSet)
-	otherExclude := make(StringSet)
+	otherInclude := make(stringset.StringSet)
+	otherExclude := make(stringset.StringSet)
 
 	words := strings.FieldsFunc(input, func(c rune) bool {
 		return unicode.IsSpace(c) || c == ','
diff --git a/pkg/types/intrange_test.go b/pkg/types/intrange_test.go
index 757dd4e..99879bb 100644
--- a/pkg/types/intrange_test.go
+++ b/pkg/types/intrange_test.go
@@ -1,15 +1,16 @@
 package types
 
 import (
-	"testing"
+		"github.com/Jguer/yay/v9/pkg/stringset"
+"testing"
 )
 
 func TestParseNumberMenu(t *testing.T) {
 	type result struct {
 		Include      IntRanges
 		Exclude      IntRanges
-		OtherInclude StringSet
-		OtherExclude StringSet
+		OtherInclude stringset.StringSet
+		OtherExclude stringset.StringSet
 	}
 
 	inputs := []string{
@@ -28,18 +29,18 @@ func TestParseNumberMenu(t *testing.T) {
 	}
 
 	expected := []result{
-		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5)}, IntRanges{}, make(StringSet), make(StringSet)},
-		{IntRanges{makeIntRange(1, 10), makeIntRange(5, 15)}, IntRanges{}, make(StringSet), make(StringSet)},
-		{IntRanges{makeIntRange(5, 10), makeIntRange(85, 90)}, IntRanges{}, make(StringSet), make(StringSet)},
-		{IntRanges{makeIntRange(1, 1), makeIntRange(99, 99), makeIntRange(60, 62)}, IntRanges{makeIntRange(2, 2), makeIntRange(5, 10), makeIntRange(38, 40), makeIntRange(123, 123)}, make(StringSet), make(StringSet)},
-		{IntRanges{}, IntRanges{}, MakeStringSet("abort", "all", "none"), make(StringSet)},
-		{IntRanges{}, IntRanges{}, MakeStringSet("a-b"), MakeStringSet("abort", "a-b")},
-		{IntRanges{}, IntRanges{}, MakeStringSet("-9223372036854775809-9223372036854775809"), make(StringSet)},
-		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5)}, IntRanges{}, make(StringSet), make(StringSet)},
-		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5), makeIntRange(6, 6), makeIntRange(7, 7), makeIntRange(8, 8)}, IntRanges{}, make(StringSet), make(StringSet)},
-		{IntRanges{}, IntRanges{}, make(StringSet), make(StringSet)},
-		{IntRanges{}, IntRanges{}, make(StringSet), make(StringSet)},
-		{IntRanges{}, IntRanges{}, MakeStringSet("a", "b", "c", "d", "e"), make(StringSet)},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 10), makeIntRange(5, 15)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(5, 10), makeIntRange(85, 90)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(99, 99), makeIntRange(60, 62)}, IntRanges{makeIntRange(2, 2), makeIntRange(5, 10), makeIntRange(38, 40), makeIntRange(123, 123)}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, stringset.Make("abort", "all", "none"), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, stringset.Make("a-b"), stringset.Make("abort", "a-b")},
+		{IntRanges{}, IntRanges{}, stringset.Make("-9223372036854775809-9223372036854775809"), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5), makeIntRange(6, 6), makeIntRange(7, 7), makeIntRange(8, 8)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, stringset.Make("a", "b", "c", "d", "e"), make(stringset.StringSet)},
 	}
 
 	for n, in := range inputs {
@@ -48,8 +49,8 @@ func TestParseNumberMenu(t *testing.T) {
 
 		if !intRangesEqual(include, res.Include) ||
 			!intRangesEqual(exclude, res.Exclude) ||
-			!StringSetEqual(otherInclude, res.OtherInclude) ||
-			!StringSetEqual(otherExclude, res.OtherExclude) {
+			!stringset.Equal(otherInclude, res.OtherInclude) ||
+			!stringset.Equal(otherExclude, res.OtherExclude) {
 
 			t.Fatalf("Test %d Failed: Expected: include=%+v exclude=%+v otherInclude=%+v otherExclude=%+v got include=%+v excluive=%+v otherInclude=%+v otherExclude=%+v",
 				n+1, res.Include, res.Exclude, res.OtherInclude, res.OtherExclude, include, exclude, otherInclude, otherExclude)
diff --git a/print.go b/print.go
index 5f0e95d..3995ec0 100644
--- a/print.go
+++ b/print.go
@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/Jguer/yay/v9/pkg/types"
+	"github.com/Jguer/yay/v9/pkg/stringset"
 	rpc "github.com/mikkeloscar/aur"
 )
 
@@ -390,7 +391,7 @@ func printNumberOfUpdates() error {
 
 //TODO: Make it less hacky
 func printUpdateList(parser *arguments) error {
-	targets := types.SliceToStringSet(parser.targets)
+	targets := stringset.SliceToStringSet(parser.targets)
 	warnings := &aurWarnings{}
 	old := os.Stdout // keep backup of the real stdout
 	os.Stdout = nil
diff --git a/query.go b/query.go
index 2ec42bb..d05458d 100644
--- a/query.go
+++ b/query.go
@@ -10,6 +10,7 @@ import (
 
 	alpm "github.com/Jguer/go-alpm"
 	"github.com/Jguer/yay/v9/pkg/types"
+	"github.com/Jguer/yay/v9/pkg/stringset"
 	rpc "github.com/mikkeloscar/aur"
 )
 
@@ -363,7 +364,7 @@ func hangingPackages(removeOptional bool) (hanging []string, err error) {
 	// State = 2 - Keep package and have iterated over dependencies
 	safePackages := make(map[string]uint8)
 	// provides stores a mapping from the provides name back to the original package name
-	provides := make(types.MapStringSet)
+	provides := make(stringset.MapStringSet)
 	packages := localDB.PkgCache()
 
 	// Mark explicit dependencies and enumerate the provides list
diff --git a/upgrade.go b/upgrade.go
index e3b7903..6a299ab 100644
--- a/upgrade.go
+++ b/upgrade.go
@@ -8,6 +8,7 @@ import (
 
 	alpm "github.com/Jguer/go-alpm"
 	"github.com/Jguer/yay/v9/pkg/types"
+	"github.com/Jguer/yay/v9/pkg/stringset"
 	rpc "github.com/mikkeloscar/aur"
 )
 
@@ -169,7 +170,7 @@ func upList(warnings *aurWarnings) (upSlice, upSlice, error) {
 	printLocalNewerThanAUR(remote, aurdata)
 
 	if develUp != nil {
-		names := make(types.StringSet)
+		names := make(stringset.StringSet)
 		for _, up := range develUp {
 			names.Set(up.Name)
 		}
@@ -330,9 +331,9 @@ func upRepo(local []alpm.Package) (upSlice, error) {
 }
 
 // upgradePkgs handles updating the cache and installing updates.
-func upgradePkgs(aurUp, repoUp upSlice) (types.StringSet, types.StringSet, error) {
-	ignore := make(types.StringSet)
-	aurNames := make(types.StringSet)
+func upgradePkgs(aurUp, repoUp upSlice) (stringset.StringSet, stringset.StringSet, error) {
+	ignore := make(stringset.StringSet)
+	aurNames := make(stringset.StringSet)
 
 	allUpLen := len(repoUp) + len(aurUp)
 	if allUpLen == 0 {
diff --git a/utils_test.go b/utils_test.go
new file mode 100644
index 0000000..947c3a0
--- /dev/null
+++ b/utils_test.go
@@ -0,0 +1,33 @@
+package main
+
+import "testing"
+
+func TestLessRunes(t *testing.T) {
+	t.Parallel()
+	type args struct {
+		iRunes []rune
+		jRunes []rune
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{name: "nilslices", args: args{iRunes: nil, jRunes: nil}, want: false},
+		{name: "emptyslices", args: args{iRunes: []rune{}, jRunes: []rune{}}, want: false},
+		{name: "simpleslice a,b", args: args{iRunes: []rune{'a'}, jRunes: []rune{'b'}}, want: true},
+		{name: "simpleslice b,a", args: args{iRunes: []rune{'b'}, jRunes: []rune{'a'}}, want: false},
+		{name: "equalslice", args: args{iRunes: []rune{'a', 'a', 'a'}, jRunes: []rune{'a', 'a', 'a'}}, want: false},
+		{name: "uppercase", args: args{iRunes: []rune{'a'}, jRunes: []rune{'A'}}, want: false},
+		{name: "longerFirstArg", args: args{iRunes: []rune{'a', 'b'}, jRunes: []rune{'a'}}, want: false},
+		{name: "longerSecondArg", args: args{iRunes: []rune{'a'}, jRunes: []rune{'a', 'b'}}, want: true},
+		{name: "utf8 less", args: args{iRunes: []rune{'世', '2', '0'}, jRunes: []rune{'世', '界', '3'}}, want: true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := LessRunes(tt.args.iRunes, tt.args.jRunes); got != tt.want {
+				t.Errorf("LessRunes() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/vcs.go b/vcs.go
index 164113e..f6ea7b2 100644
--- a/vcs.go
+++ b/vcs.go
@@ -9,7 +9,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/Jguer/yay/v9/pkg/types"
+	"github.com/Jguer/yay/v9/pkg/stringset"
 	gosrc "github.com/Morganamilo/go-srcinfo"
 )
 
@@ -38,7 +38,7 @@ func createDevelDB() error {
 	}
 
 	bases := getBases(info)
-	toSkip := pkgbuildsToSkip(bases, types.SliceToStringSet(remoteNames))
+	toSkip := pkgbuildsToSkip(bases, stringset.SliceToStringSet(remoteNames))
 	_, err = downloadPkgbuilds(bases, toSkip, config.BuildDir)
 	if err != nil {
 		return err